@descix/frqtl-node 0.6.1-p3.1 → 0.6.1-p3.3

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.1 on npm dist-tag `next`. Node ≥ 22.12.
+> `bootNode` and the hosted eyes. 0.6.1-p3.3 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.1/CLAUDE.md
+- Full agent guide: https://cdn.jsdelivr.net/npm/@descix/frqtl-node@0.6.1-p3.3/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.1",
+  "version": "0.6.1-p3.3",
   "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": {