@descix/frqtl-node 0.6.1-p3.2 → 0.6.1-p3.4

package/dist/frqtl/parts/Wall.js

@@ -971,7 +971,7 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
             'on. Zero physics of its own.',
         // STUDIO UX presentation contract (A0 vocab, owned at lib/shim/field-descriptor).
         // A wall has a genuine draggable/resizable extent (unlike the two-radii
-        // SphereEmitter) → resizable:true. 2D drag only (3D reposition via the camera).
+        // SphereEmitter) → resizable:true (resize zones are 2D; the 3D Hand only moves).
         // shellRender:'run' — a wall is a boundary you SEE during Run (not a Design-only
         // marker like an emitter), so its shell always paints.
         ux: {

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

@@ -44,7 +44,6 @@
 import { CameraControls, FrqtlControlOverlay, FrqtlControlsPanel, GraphingDetectorWall, SphereEmitter, Tunnel, Wall } from '@descix/frqtl-web/parts';
 import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
 import * as FrqtlDisplay from '@descix/frqtl-web/compat/renderer/display-slot.js';
-import * as SunLook from '@descix/frqtl-web/shim/render/sun-look.js';
 
 const CW = 600, H = 400, WORLD_D = 600;   // THE WORLD this scene states (its co-init call below)
 // GEOMETRY and WAVELENGTH are two INDEPENDENT dials, and they are kept apart on
@@ -224,33 +223,45 @@ export default function buildExperiment(exp) {
       collisionBehavior: 'destroy', name: 'zClipFar', visible: false });
     exp.addObject('Wall', { rect: [0, 0, CW, H], z: -zHalf - 40, depth: 40,
       collisionBehavior: 'destroy', name: 'zClipNear', visible: false });
-    // THE SWITCH: god-rays computed from the light particles only (godraySource
-    // 'leaf'), at the sun's settings — the ONE owner of those numbers is lib/shim/render/sun-look.js
-    // (SunLook); this file types none of them. Default OFF (the first-contact picture is
-    // unchanged). OFF restores EXACTLY what was live before the last ON (a host row, a STUDIO
-    // slider), through the same declared door; a value the renderer does not declare THROWS there.
-    // The knob shows its last written value (a render write has no read-back). The picture changes
-    // at the next drawn tick, so in a paused (Design) view it shows once the scene runs.
-    var RAYS_ON = Object.assign({}, SunLook.SUN_GODRAYS, { godraySource: 'leaf' });
-    var raysPrior = null;   // the three live values captured at ON; written back at OFF
+    // PACING (wall-clock only, never the ticks): 240 ticks/s, four times the 1:1 lock on a
+    // 60 Hz display, so the interference bands build up four times sooner in real time.
+    exp.runner.setRateLimits({ tpsLimit: 240 });
+    // THE SWITCH: this scene's god-ray look, computed from the light particles only (godraySource
+    // 'leaf') with the 'field' pass (each pixel marches along the local direction of travel), and the
+    // per-layer glow under it. The numbers are this scene's own, set by eye against a reference
+    // STUDIO picture (godrays 2.2 of [0, 3], godrayDensity 1.5 = the top of [0.2, 1.5],
+    // glowIntensity 0.66 of [0, 3]); the renderer declares the keys and their ranges and refuses any
+    // other. Default ON: the scene writes ON once at build, through the same function the knob calls.
+    // OFF restores EXACTLY what was live before the last ON (a host row, a STUDIO slider), through
+    // the same declared door. The knob shows its last written value (a render write has no
+    // read-back). The picture changes at the next drawn tick, so in a paused (Design) view it shows
+    // once the scene runs.
+    var RAYS_ON = { godrays: 2.2, godrayDensity: 1.5, godrayMode: 'field', godraySource: 'leaf', glowIntensity: 0.66 };
+    var RAYS_DEFAULT = 1;
+    var raysPrior = null;   // the live values of RAYS_ON's keys captured at ON; written back at OFF
+    function setRays(v) {
+      if (v) {
+        // Capture only on the OFF -> ON edge: an ON pressed while already ON keeps the pre-ON state.
+        if (!raysPrior) {
+          raysPrior = {};
+          Object.keys(RAYS_ON).forEach(function (k) { raysPrior[k] = exp.runner.getRenderOption(k); });
+        }
+        exp.runner.setRenderOptions(RAYS_ON);
+      } else if (raysPrior) {
+        exp.runner.setRenderOptions(raysPrior);
+        raysPrior = null;
+      }
+      // OFF with nothing captured: nothing was written by this switch — no write.
+    }
     var knobs = ControlRegistry.makeControlRegistry();
     knobs.registerControls('dse-tunnel-rebuild', [
       { kind: 'scalar', id: 'godrays', label: 'god rays', channel: 'render', widget: 'toggle',
-        min: 0, max: 1, step: 1, value: 0,
+        min: 0, max: 1, step: 1, value: RAYS_DEFAULT,
         fmt: function (v) { return v ? 'on' : 'off'; },
-        onChange: function (v) {
-          if (v) {
-            raysPrior = {};
-            Object.keys(RAYS_ON).forEach(function (k) { raysPrior[k] = exp.runner.getRenderOption(k); });
-            exp.runner.setRenderOptions(RAYS_ON);
-          } else if (raysPrior) {
-            exp.runner.setRenderOptions(raysPrior);
-            raysPrior = null;
-          }
-          // OFF with nothing captured: the control is at its initial OFF and has written nothing — no write.
-        },
+        onChange: setRays,
         place: { x: 0.02, y: 0.04 } }
     ]);
+    setRays(RAYS_DEFAULT);
     // Chrome (a page only): expose the knob to a host frame, and mount the overlay through the
     // runner's ONE door (runner.controlHost) — before a canvas is mounted (a notebook pane) there is
     // none, so the knob stays in the exposed registry only.

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

@@ -32,10 +32,10 @@
 //   (d) the population counter carries a z-slab covering the WHOLE universe z-band (the emitter's
 //       gateCounter names it, so it stays a code declaration);
 //   (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.
+// The 3D mode's render intent — the particles hidden so the light field alone shows, strong
+// 'field' god-rays computed from the light particles only (godraySource 'leaf'), a soft glow, and
+// a face-on camera close enough that the ring spans the canvas height — rides the registry mode's
+// renderState (lib/shim/registry/walkthrough.js), its one home.
 
 import { CameraControls, SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 import * as FrqtlDisplay from '@descix/frqtl-web/compat/renderer/display-slot.js';
@@ -64,6 +64,9 @@ const vpos = function (v) { var a = (v * 36 + ROT) * D2R; return [CX + R * Math.
 const pos = order.map(vpos);
 const deg = function (a) { return ((a * 180 / Math.PI) % 360 + 360) % 360; };
 const angOf = function (p, q) { return deg(Math.atan2(q[1] - p[1], q[0] - p[0])); };
+// Where each mirror belongs: m1..m10 by name, at its star vertex (the centre of the slot in the ring). m4 and m6
+// are declared off theirs below; STUDIO's "try it" reads this to know when a dragged mirror is home.
+export const starPoints = Object.freeze(Object.fromEntries(pos.map(function (p, i) { return ['m' + (i + 1), Object.freeze(p.slice())]; })));
 // 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.
@@ -101,9 +104,10 @@ export const parts = {
   m1: [Wall, { rect: [Math.round(pos[0][0] - SW / 2), Math.round(pos[0][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[0], color: PAL[0], hooks: ['recolor'] }],
   m2: [Wall, { rect: [Math.round(pos[1][0] - SW / 2), Math.round(pos[1][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[1], color: PAL[1], hooks: ['recolor'] }],
   m3: [Wall, { rect: [Math.round(pos[2][0] - SW / 2), Math.round(pos[2][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[2], color: PAL[2], hooks: ['recolor'] }],
-  m4: [Wall, { rect: [Math.round(pos[3][0] - SW / 2), Math.round(pos[3][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[3], color: PAL[3], hooks: ['recolor'] }],
+  // m4 and m6 stand OFF their star vertices (m4 5 px right, m6 67 px toward the centre): the ring opens broken, so dragging one home is the thing to try.
+  m4: [Wall, { rect: [437, 103, SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[3], color: PAL[3], hooks: ['recolor'] }],
   m5: [Wall, { rect: [Math.round(pos[4][0] - SW / 2), Math.round(pos[4][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[4], color: PAL[4], hooks: ['recolor'] }],
-  m6: [Wall, { rect: [Math.round(pos[5][0] - SW / 2), Math.round(pos[5][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[5], color: PAL[5], hooks: ['recolor'] }],
+  m6: [Wall, { rect: [215, 142, SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[5], color: PAL[5], hooks: ['recolor'] }],
   m7: [Wall, { rect: [Math.round(pos[6][0] - SW / 2), Math.round(pos[6][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[6], color: PAL[6], hooks: ['recolor'] }],
   m8: [Wall, { rect: [Math.round(pos[7][0] - SW / 2), Math.round(pos[7][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[7], color: PAL[7], hooks: ['recolor'] }],
   m9: [Wall, { rect: [Math.round(pos[8][0] - SW / 2), Math.round(pos[8][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[8], color: PAL[8], hooks: ['recolor'] }],

package/dist/shim/engine/router.js

@@ -152,7 +152,7 @@ var DIST_PROFILE = buildDistProfile('../..');
 // lib/shim/engine/test/router.test.mjs asserts them against the two
 // package.json#version fields so a forgotten bump fails `make verify`, not a
 // silent stale-CDN-URL bug.
-var CDN_SDK_VERSION = '0.6.1-p3.2';  // sdk/frqtl-web/package.json#version (the ONE version owner) — bound by router.test.mjs
+var CDN_SDK_VERSION = '0.6.1-p3.4';  // sdk/frqtl-web/package.json#version (the ONE version owner) — bound by router.test.mjs
 var CDN_MATH_SDK_VERSION = '0.3.3-p2.1';  // sdk/egpt-math-sdk/package.json#version — bound by router.test.mjs; bumped with each npm publish
 
 /**
@@ -526,7 +526,7 @@ var _assertProfileParity = (function () {
  * // CDN mode (static hosting — the artifact host shell has no server, no page anchor):
  * const cdnRouter = engineRouter({ mode: 'cdn', engine: 'wasm' });
  * console.log(cdnRouter.resolve('compat/engine.js'));
- * // 'https://cdn.jsdelivr.net/npm/@descix/frqtl-web@0.6.1-p3.2/dist/frqtl/compat/engine.js'
+ * // 'https://cdn.jsdelivr.net/npm/@descix/frqtl-web@0.6.1-p3.4/dist/frqtl/compat/engine.js'
  *
  * // CDN mode, self-hosted: a copy of dist/ served from the consumer's own origin:
  * const selfHosted = engineRouter({ mode: 'cdn', engine: 'wasm', base: 'https://example.org/vendor/frqtl-web/dist' });

package/dist/shim/field-descriptor/index.js

@@ -199,8 +199,8 @@ var UX_HANDLE_ZONES = Object.freeze([
     'scale-t', 'scale-b', 'scale-l', 'scale-r'
 ]);
 
-// The render modes a part may be cursor-dragged in. Only 2D: a 3D scene never cursor-drags
-// (reposition is the aim + SPACE carry), so there is no per-object 3D knob to declare.
+// The keys of a ux `draggable` block. Declared data only: STUDIO's Hand drag (2D and 3D) moves
+// any declared object with a position authority and does not read it.
 var UX_DRAGGABLE_MODES = Object.freeze(['2d']);
 
 // When a manipulable object's visual shell renders (generalizes the
@@ -236,8 +236,8 @@ function _uxFail(msg) {
  *   resizable         — boolean (default true). false ⇒ scale handles are never
  *                       offered even for the SELECTED object (its corners never
  *                       resize; the first-and-every interaction is select/move).
- *   draggable         — { '2d':boolean } (default true). false disables the 2D
- *                       cursor-drag. (A 3D scene never cursor-drags; '3d' is not a key.)
+ *   draggable         — { '2d':boolean } (default true). Declared data only: no STUDIO
+ *                       surface reads it ('3d' is not a key).
  *   handles           — string[] ⊆ UX_HANDLE_ZONES (default = ALL zones). The
  *                       live interaction zones; a zone NOT listed is downgraded
  *                       to 'move' by the overlay (never a resize on the selecting
@@ -273,7 +273,7 @@ function normalizeUx(partial) {
         Object.keys(partial.draggable).forEach(function (k) {
             if (UX_DRAGGABLE_MODES.indexOf(k) === -1) {
                 _uxFail('"draggable.' + k + '" is not a draggable mode ([' + UX_DRAGGABLE_MODES.join(', ') +
-                    ']) — a 3D scene never cursor-drags.');
+                    ']).');
             }
         });
         var dr = { '2d': true };

package/dist/shim/host/device.js

@@ -11,10 +11,14 @@
  *                         page (an app framed by the DeSciX shell measures its own frame). A window without
  *                         matchMedia THROWS: every browser has it, so its absence is a caller passing the wrong object.
  *
- * Its two consumers ask it once each, at load:
+ * Its three consumers ask it once each, at load:
  *   - the host-view call site (apps/ide/src/host-view-entry.js) asks the shell for NoChrome on a phone, CodeSite
  *     elsewhere;
- *   - STUDIO (lib/features/ide/AuthorView.jsx) opens with its side panels collapsed on a phone.
+ *   - STUDIO (lib/features/ide/AuthorView.jsx) opens with its side panels collapsed on a phone and puts its Hand tool
+ *     between the camera joysticks (the phone toolbar Move | Hand | Look), and words its mirror "try it" for that
+ *     surface (lib/features/ide/studio-try-it.js);
+ *   - FraqtlIde (lib/features/ide/index.jsx) opens the STUDIO tab card with the controls of that surface
+ *     (presets.js presetExplainerFor).
  * The static build compiles it into both: the stable host-view entry is bundled as its own self-contained module
  * (apps/ide/vite.config.js frqtl-host-view-entry), the IDE's rollup graph carries its own copy of the same source.
  *

package/dist/shim/registry/exhibits.js

@@ -162,9 +162,18 @@ assertShowcaseIntro(SHOWCASE_INTRO);
 // (the egpt-frqtl front page's #proof tiles: each tile's <b> and its sentence), verbatim;
 // `what`, `why`, `how`, `controls` and each `still.alt` are the authored captions.
 const ROSTER = [
+    {
+        kind: 'rung', id: "cl1d-mirror-route", mode: "3d",
+        still: { tick: 3600, alt: "Ten brightly coloured mirror blocks in a ring, seen face-on, one cyan block on the right standing inside the ring out of its place; a thick, glowing band of gold, red, pink and green light swirls around a dark centre holding faint purple and green eddies, and green and pink rays reach out between the mirrors into the dark." },
+        title: "Infinite mirror",
+        tile: "Ten mirrors in a ring. Light walks the loop. No Fresnel equations.",
+        what: "Ten mirrors in a ring. Light goes round and round the loop, reflected and diffused from mirror to mirror, each mirror colouring the light it sends on.",
+        why: "Conventional renderers cut every light path off after a set number of bounces and treat shadows, reflections and indirect light as separate effects. Solving the light directly in a 5 m room would take Frontier about 3 billion years.",
+        how: "One emitter and ten walls set as mirrors. Light leaves in every direction; shadowing, reflection and obstruction are all live, with no limit on the objects in its path, and the diffusion is real. No Fresnel equations.",
+    },
     {
         kind: 'rung', id: "dse-tunnel-rebuild", mode: "3d",
-        still: { tick: 7200, alt: "Three red blocks with blue slit walls between them inside a dark glass box; a cloud of yellow dots hangs above the slits, and below them a flat heat-map plate of blue squares glows yellow-green along a central band." },
+        still: { tick: 7200, alt: "Three red blocks with blue slit walls between them, seen at a tilt from behind the source; a fan of yellow rays spreads from a point at lower left into the slits, and beyond them, at upper right, a heat-map plate of blue and green squares shows light and dark bands with a red hot spot at its centre." },
         title: "Double slit",
         tile: "Two slits, one particle at a time. Feynman's “only mystery,” with no amplitudes to add.",
         what: "Particles go through two slits one at a time, and bright and dark bands build up on the detector plate below them, live in your browser tab: the pattern Feynman called quantum mechanics' \"only mystery\". EGPT conceptually holds computer science and physics are linked by P=NP and the principle of least action - that is, everything in reality is efficiently computable. The Lean RET, the derivation of EntropyReal from an IIDParticleSource, and the P=NP capstones are modern formalizations of proofs and ideas advanced by Gian-Carlo Rota circa the late 1970s. The EGPT Lean proofs transparently show the most rigorously advanced proofs ever offered for bridging not only quantum and classical mechanics but mathematics and all the other sciences. Watch it run, read its code, and judge for yourself whether this is true P=NP quantum computing.",
@@ -180,15 +189,6 @@ const ROSTER = [
         why: "Games paint glow and god rays onto the finished picture as a separate screen effect, aimed from where the sun is on the screen rather than from any light in the scene.",
         how: "One sphere emitter, shining in every direction. The god rays are rendered from the density of the particles themselves. No Standard Model, no equations, and the engine does not know whether you are looking at a star, a candle flame or an atom.",
     },
-    {
-        kind: 'rung', id: "cl1d-mirror-route", mode: "3d",
-        still: { tick: 1200, alt: "Ten brightly coloured mirrors in a ring, seen from above; a dense band of gold, orange and green dots circles a dark, empty centre inside it, and faint gold and green rays fan out from that light between the mirrors into the dark space around." },
-        title: "Infinite mirror",
-        tile: "Ten mirrors in a ring. Light walks the loop. No Fresnel equations.",
-        what: "Ten mirrors in a ring. Light goes round and round the loop, reflected and diffused from mirror to mirror, each mirror colouring the light it sends on.",
-        why: "Conventional renderers cut every light path off after a set number of bounces and treat shadows, reflections and indirect light as separate effects. Solving the light directly in a 5 m room would take Frontier about 3 billion years.",
-        how: "One emitter and ten walls set as mirrors. Light leaves in every direction; shadowing, reflection and obstruction are all live, with no limit on the objects in its path, and the diffusion is real. No Fresnel equations.",
-    },
     {
         kind: 'rung', id: "r5-fountain-pool",
         still: { tick: 300, alt: "A dark teal surface scattered with white glints like light on water, with a faint ring around a dark dot at its centre." },

package/dist/shim/registry/walkthrough.js

@@ -258,7 +258,9 @@ export var WALKTHROUGH = [
                'tall/thin mirrors sit at the vertices of a regular decagon; each mirror\'s tilt is ' +
                'solved from its incoming/outgoing chords so the reflected centre-line hits the next ' +
                'mirror exactly, and by the star\'s symmetry the tenth leg feeds straight back into ' +
-               'the first — the polygon closes on itself. Each mirror is a DIFFERENT colour and, on ' +
+               'the first — the polygon closes on itself. The scene OPENS with two mirrors (m4, m6) standing ' +
+               'off their vertices, so the ring starts broken and the light spills: drag one home with the ' +
+               'Hand and watch the field reshape live. Each mirror is a DIFFERENT colour and, on ' +
                'collision, TAGS the beam with its own colour (its drawn colour = its identity): so a ' +
                'particle\'s colour history IS its bounce sequence — red after m1, orange after m2, … ' +
                'magenta after m10, then red again as it re-enters the loop (a pkg-node colour-transition ' +
@@ -280,19 +282,26 @@ export var WALKTHROUGH = [
                'plateaus and FPS stays healthy while the circuit runs indefinitely — and the gate ' +
                'survives Restart (it is captured descriptor DATA, not recipe code).',
         source: 'scenes/mirror-route.js',
-        // 3D FIRST = the rung's DEFAULT mode (the first declared entry). It opens on the
-        // 'table-top' camera preset (three-camera-contract.js cameraPresets) with god-rays on at
-        // the sun's settings (SunLook.SUN_GODRAYS, owned by lib/shim/render/sun-look.js), computed
-        // from the light particles only (godraySource 'leaf'), so the mirrors shadow the beam and
-        // cast no rays.
+        // 3D FIRST = the rung's DEFAULT mode (the first declared entry), and this rung is FIRST
+        // CONTACT (FIRST_CONTACT_WALKTHROUGH_ID below). It opens face-on to the ring (the
+        // 'table-top' preset's axes: azimuth 0, elevation 0, roll 0) but closer than that preset's
+        // 780, at distance 440, so the top and bottom slabs sit near the canvas's top and bottom
+        // edges. The look is the one a reference STUDIO session exported for this scene: the
+        // particles hidden (renderBaseCanvas false), so the picture is the light field alone — strong
+        // 'field' god rays computed from the light particles only (godraySource 'leaf'), so the
+        // mirrors shadow the beam and cast no rays — plus a soft glow. Every other render option
+        // that session exported sat at the renderer's own default, so it is not restated here.
         // The 2D mode stays one click away on the MODE strip.
         modes: [
             {
                 id: '3d', label: '3D',
                 renderState: {
                     renderer: 'three',
-                    camera: { orbit: null, preset: 'table-top' },
-                    render: renderRowsFromBag(Object.assign({}, SunLook.SUN_GODRAYS, { godraySource: 'leaf' }))
+                    camera: { orbit: { azimuth: 0, elevation: 0, distance: 440, roll: 0 }, preset: null },
+                    render: renderRowsFromBag({
+                        renderBaseCanvas: false, godrays: 3, godrayDensity: 1.085,
+                        godraySource: 'leaf', godrayMode: 'field', glowIntensity: 0.27
+                    })
                 }
             },
             { id: '2d', label: '2D' }
@@ -375,89 +384,26 @@ export var WALKTHROUGH = [
         renderState: {
             render: [{ key: 'colorScheme', value: 'roygbiv' }]
         },
-        // 3D FIRST = the rung's DEFAULT mode (the first declared entry), because this
-        // rung is FIRST CONTACT: STUDIO opens on it, and the thing a newcomer should
-        // meet is the experiment standing up in space with a camera they can move.
-        // The 2D mode stays one click away on the MODE strip.
+        // 3D FIRST = the rung's DEFAULT mode (the first declared entry): the experiment
+        // standing up in space with a camera you can move. The 2D mode stays one click away
+        // on the MODE strip.
         modes: [
             {
                 id: '3d', label: '3D',
-                // FIRST-CONTACT FRAMING: the camera stands BEHIND the emitter, facing the
-                // slit wall slightly rotated, so the interference builds up partially
-                // visible and invites the viewer to move the camera.
-                //
-                // DERIVED FROM THE SCENE, not tuned against a picture. The camera sits at
-                //     target + d·(cos el·sin az, sin el, cos el·cos az)
-                // looking back at `target` (three-provider `_applyOrbit`, world y-DOWN).
-                //   target (138, 200, 0) — the midpoint of the WORKING LENGTH (emitter
-                //                  x=20 → detector far face x=256) at the beam height
-                //                  (H/2): (20 + 256)/2 = 138. It is DERIVED from the
-                //                  geometry, so it moves whenever the detector does. The
-                //                  default centre is the CANVAS centre x=300, which sits
-                //                  PAST the detector: orbiting about it swings the
-                //                  experiment around a point outside itself and pushes
-                //                  the near objects into the lens. The experiment orbits
-                //                  about the experiment.
-                //   azimuth -60  → sin az = -0.866 ⇒ camera x = 138 - 0.82·d ≈ -257 at
-                //                  d = 480: BEHIND the emitter, looking down +x through the
-                //                  slit wall (x = 96..160) toward the detector (x = 236).
-                //                  cos az = 0.5 swings it 30° off that axis in z — the
-                //                  "slightly rotated" part: dead-on, the slit wall would
-                //                  eclipse the detector completely; at 30° the detector's
-                //                  own hit map shows PAST the barrier edge, partially, which
-                //                  is exactly the invitation to orbit.
-                //   elevation -18 → sin el < 0 ⇒ a smaller world y = ABOVE the beam plane
-                //                  (y-down): a gentle look down onto it, so the slit plate
-                //                  and the tunnels read as solids rather than edge-on lines.
-                //   distance 480  → the full 256-px working length and the 400-px canvas
-                //                  height inside the fixed 50° vertical FOV, with the
-                //                  quanta streaming through the slits still legible. It
-                //                  frames the working length, so it is re-derived with the
-                //                  geometry — and by MEASUREMENT (project the scene's
-                //                  bounding box through the camera basis and read the frame
-                //                  fill: 480 gives max|ndc| 0.851), never by scaling the
-                //                  span, which over-corrects because the working length runs
-                //                  mostly ALONG the view direction and foreshortens.
-                //   roll +90     → the SLIT-SEPARATION AXIS onto the screen HORIZONTAL.
-                //                  Derived from the scene like the rest, and forced by a
-                //                  constraint 2D imposes on 3D: 2D has only x and y, so with
-                //                  the beam on x the ONLY transverse axis available is y —
-                //                  the slits MUST split along y and the fringes MUST spread
-                //                  along y. 3D reuses that one setup (2D≡3D is this rung's
-                //                  headline), so it inherits a floor-to-ceiling wall with the
-                //                  detector eclipsed behind it. No orbit parameter can fix
-                //                  that: `elevation` moves the eye along ±y, which is the
-                //                  slit-separation axis itself, so "getting above it" slides
-                //                  the eye ALONG the pattern instead of over the wall. ROLL is
-                //                  the missing degree of freedom — it turns the VIEWER about
-                //                  the beam axis, leaving the world untouched, and lands world
-                //                  y (fringe spread) on the screen horizontal and world z (the
-                //                  corridor extrusion) on the vertical: a WIDE, low plate with
-                //                  the two slots SIDE BY SIDE and the fringes reading as bands
-                //                  left-to-right — the textbook DSE picture. The plate's
-                //                  on-screen bounding box goes 182×648 (tall) → 648×182 (wide);
-                //                  the framing is otherwise IDENTICAL, since a roll moves
-                //                  neither the eye nor the radius.
-                //                  THE SIGN is the visually approved one. Measured through
-                //                  `_orbitCameraBasis` at this exact pose (detector plate
-                //                  corners, 600×600): at roll +90 the low-y corner projects to
-                //                  screen-x 20.9 px and the high-y corner to 633.0 px (+y →
-                //                  RIGHT); at roll −90 they land at 579.1 px and −33.0 px
-                //                  (+y → LEFT). Both are equally "wide".
+                // THE DSE'S OPENING FRAMING, a choice about what to show first, fitted to a reference STUDIO
+                // picture: close in, rolled so the barrier runs from upper left down to lower right
+                // across the canvas with its two slits near the centre, the detector plate above and
+                // behind it showing its bands and running off the top edge, and the emitter's
+                // god-ray fan spreading from the lower left. The orbit revolves about
+                // `target`, the midpoint of the working length (emitter x=20 to the detector's
+                // far face) at the beam height H/2, so it moves whenever the detector does.
                 //   preset: null — deliberately NOT a named preset. `setPreset` is a FULL
-                //                  framing reset: it forces `target: null` (and now `roll: 0`),
-                //                  which is exactly what makes the preset buttons the reliable
-                //                  way back — and exactly why they cannot express this pose,
-                //                  whose whole point is the scene-derived `target` above.
-                // NOT a compensator: the former azimuth:38 papered over a renderer defect
-                // (a ferried canvas drawn with a y-up UV assumption in the y-down world,
-                // on a single-sided plane), fixed at the root — orientation is derived in
-                // world space and both broad faces carry the map, so every orbit is now
-                // equally correct. This pose is a CHOICE about what to show first.
+                //                  framing reset (it forces `target: null` and `roll: 0`), so the
+                //                  preset buttons are the way back and cannot express this pose.
                 renderState: {
                     renderer: 'three',
                     camera: {
-                        orbit: { azimuth: -60, elevation: -18, distance: 546, roll: 90,
+                        orbit: { azimuth: -26, elevation: -18, distance: 440, roll: -115,
                                  target: { x: 177.5, y: 200, z: 0 } },
                         preset: null
                     }
@@ -737,15 +683,17 @@ export function effectiveRenderState(rung, modeId) {
  * than silently landing on a blank canvas.
  *
  * ── Layer 2: what it shows ───────────────────────────────────────────────────
- * The double-slit rebuilt on the Tunnel object, in its DEFAULT (3D) mode: the
- * camera stands behind the emitter looking obliquely at the slit wall, and the
- * interference pattern builds on the detector plate while you watch. This is
- * PRODUCT INTENT — the first thing FRQTL shows is its signature experiment, framed
- * so the pattern is already forming and the camera is obviously yours to move.
+ * The infinite mirror (the ten-mirror {10/3} star) in its DEFAULT (3D) mode, face-on:
+ * the light field itself, shadowed and reflected live by the mirrors, with two
+ * mirrors standing off their star positions so the first thing to try is dragging
+ * one home with the Hand. PRODUCT INTENT — the first thing FRQTL shows is light
+ * doing what light does, computed live, with objects that are obviously yours to move.
+ * The showcase roster's first tile (exhibits.js EXHIBITS[0]) is this rung too; its
+ * test holds the two equal.
  *
  * @type {string}
  */
-export var FIRST_CONTACT_WALKTHROUGH_ID = 'dse-tunnel-rebuild';
+export var FIRST_CONTACT_WALKTHROUGH_ID = 'cl1d-mirror-route';
 
 /**
  * walkthroughById(id) — id → rung, or null. The ONE resolver every consumer of a

package/dist/shim/render/capture-envelope.js

@@ -175,6 +175,26 @@ function bytesToBase64(bytes) {
     return btoa(bin);
 }
 
+/**
+ * base64ToBytes(b64) — the inverse of `bytesToBase64`: an envelope's `encoded.bytes` back to the bytes a
+ * consumer saves or plays (a page turning a recording into a file). One encoding, one owner of both directions.
+ *
+ * @param {string} b64
+ * @returns {Uint8Array}
+ */
+function base64ToBytes(b64) {
+    if (typeof b64 !== 'string') {
+        _fail('base64ToBytes expects the base64 string of encoded.bytes, got ' + typeof b64);
+    }
+    if (typeof atob !== 'function') {
+        _fail('base64ToBytes needs a global atob (every browser, and node >= 16)');
+    }
+    var bin = atob(b64);
+    var out = new Uint8Array(bin.length);
+    for (var i = 0; i < bin.length; i++) { out[i] = bin.charCodeAt(i); }
+    return out;
+}
+
 /**
  * Compose a single-capture envelope.
  *
@@ -274,6 +294,7 @@ export {
     ENCODED_KEYS,
     ENCODERS,
     bytesToBase64,
+    base64ToBytes,
     stillEnvelope,
     videoEnvelope
 };

package/dist/shim/render/sun-look.js

@@ -5,29 +5,24 @@
  *
  * The values are the FINAL FX bag EXACTLY as played and captured in an export session
  * (new_sun.png is the primary oracle; sun.png stays the historical dense reference), verbatim from
- * the exported renderState. They are in the write door's shape — a BAG, what
+ * the exported renderState, plus `godrayMode: 'radial'`, the mode chosen for the sun once the modes existed. They are in the write door's shape — a BAG, what
  * `runner.setRenderOptions(bag)` takes — and every key is a capability the three renderer declares.
  *
  *   SunLook.SUN_RENDER   — the sun's whole look (rung r8-sun's render rows).
- *   SunLook.SUN_GODRAYS  — the god-ray pair, PICKED from SUN_RENDER: what another scene lights up
- *                          "at the sun's settings" with (the mirror's 3D mode, the 3D DSE's switch).
  *
- * `godraySource` is NOT here: what the rays are computed from is each borrower's declared choice.
+ * `godrayMode` 'radial' is the sun's own (its rays fan from one light point, the source frames' centroid).
  * The camera is NOT here: a pose is a rung row's view, not a look.
  *
- * Readers: `lib/shim/registry/walkthrough.js` (a named import) and a scene sketch (`SunLook`, the
- * bridge's publication of this module until the game layer imports it). Zero physics: render
+ * Readers: `lib/shim/registry/walkthrough.js` (a named import); a scene sketch may import it too
+ * (`@descix/frqtl-web/shim/render/sun-look.js`). Zero physics: render
  * options are read only by the renderer.
  */
 
 
 var SUN_RENDER = Object.freeze({
     shape: 'sphere', colorScheme: 'warmcool',
-    godrays: 1.08, godrayDensity: 1.085,
+    godrays: 1.08, godrayDensity: 1.085, godrayMode: 'radial',
     glowIntensity: 0.93, heat: 0.35, smoke: 0
 });
 
-// The pair other scenes light up "at the sun's settings" with — PICKED from SUN_RENDER, never re-typed.
-var SUN_GODRAYS = Object.freeze({ godrays: SUN_RENDER.godrays, godrayDensity: SUN_RENDER.godrayDensity });
-
-export { SUN_RENDER, SUN_GODRAYS };
+export { SUN_RENDER };

package/llms.txt

@@ -1,7 +1,7 @@
 # @descix/frqtl-node
 
 > The FRQTL physics engine (compiled Rust → WASM) for node: the same modules as @descix/frqtl-web, plus
-> `bootNode` and the hosted eyes. 0.6.1-p3.2 on npm dist-tag `next`. Node ≥ 22.12.
+> `bootNode` and the hosted eyes. 0.6.1-p3.4 on npm dist-tag `next`. Node ≥ 22.12.
 
 - Install: `npm install @descix/frqtl-node`
 - `import { bootNode, Wall } from '@descix/frqtl-node'` (require() works too); `await bootNode()` → the engine handle.
@@ -9,5 +9,5 @@
 - `./project`: `linkProject` links a scene file against this package's own copy.
 - `./host-view`: `declareHostView`, `HOST_VIEW_OUTCOMES`, `CONTRACT_VIOLATIONS`, `HOST_SDK_SCRIPT` — the same declarer as @descix/frqtl-web/host-view, pure, for a node test of a call site.
 - `./register`: `node --import @descix/frqtl-node/register scene.mjs` resolves a scene's `@descix/frqtl-web/...` imports to this package.
-- Full agent guide: https://cdn.jsdelivr.net/npm/@descix/frqtl-node@0.6.1-p3.2/CLAUDE.md
+- Full agent guide: https://cdn.jsdelivr.net/npm/@descix/frqtl-node@0.6.1-p3.4/CLAUDE.md
 - Acceptance is visual; no CLI ships. No account, credits or tokens are needed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@descix/frqtl-node",
-  "version": "0.6.1-p3.2",
+  "version": "0.6.1-p3.4",
   "description": "FRQTL for node \u2014 the discrete fractal physics engine (compiled Rust \u2192 WASM), its parts as ES modules, the node engine door (bootNode) and the hosted eyes.",
   "type": "module",
   "engines": {