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

package/dist/frqtl/parts/Tunnel.js

@@ -800,7 +800,7 @@ import { setupTunnelPointExit } from '../objects/setup/setupTunnelPointExit.js';
             'reflects off the two facing mirrors and stays collimated (no random scatter, ' +
             'no leak through the walls). The group is the single author-surface entity; ' +
             'the two mirror Walls it composes carry its `_owner` up-link. Zero physics of its own.',
-        // A tunnel has a genuine draggable/resizable extent (like a Wall). 2D drag only.
+        // A tunnel has a genuine draggable/resizable extent (like a Wall).
         ux: {
             resizable: true,
             draggable: { '2d': true },

package/dist/frqtl/parts/Wall.js

@@ -774,14 +774,26 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
         return out;
     };
 
+    /** Does the op-program this wall's LargeObject is RUNNING remove the frame it triggers
+     *  on (`set 0.is_alive = …`)? Read off the program itself — the one statement of what
+     *  the wall does — never a hand list of behavior names (today: destroy and absorb). On
+     *  such a wall a frame's listing in `tickData.objects[handle].frames` is not one
+     *  arrival: the engine collects every frame in the mb_w-padded search rect
+     *  (ENGINE_CONTRACT §5.1), so a frame is listed alive through its approach ticks and
+     *  once more on its kill tick. */
+    function _runningProgramRemoves(wall) {
+        var prog = wall.lo && wall.lo.program;
+        return !!(prog && Array.isArray(prog.ops) &&
+            prog.ops.some(function (op) { return op && op.set === '0.is_alive'; }));
+    }
+
     /**
-     * LIVE-POPULATION readout (loop-polish B): the number of frames
-     * that collided with THIS wall on the sampled tick. For a FULL-AREA background
-     * wall (collisionBehavior 'nothing' + the count hook, intersects trigger) every
-     * live leaf inside the rect collides every tick, so this per-tick collided-frame
-     * count IS the current live population inside the wall — the ONE canonical
-     * "how many live" authority (replaces any host-side scan, e.g. an emission-cap
-     * thermostat's activeQuanta read).
+     * ZONE-OCCUPANCY readout (loop-polish B): the number of frames THIS wall's
+     * engine collect pass listed on the sampled tick — every frame in its search rect
+     * (the rect padded by the dimension's mb_w). For a FULL-AREA background wall
+     * (collisionBehavior 'nothing' + the count hook) that listing IS the current live
+     * population inside the wall — the ONE canonical "how many live" authority (the
+     * emission-cap gate and the LiveChart `liveCount` projector read it).
      *
      * Layer 1 (API): dual-lane, mirroring the LiveChart PROJECTOR_SPEC shape —
      *   getLiveCount(tickData) — SAMPLE lane (per tick): read
@@ -794,12 +806,23 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
      * COUNT increment only (bench LO7); counting never moves, kills, or recolors a
      * frame (SU1).
      *
-     * Guard: THROWS on a wall without the count hook / legacy detect behavior (no
-     * collected-frames buffer → it would silently report 0 forever).
+     * Guards: THROWS on a REMOVING wall (destroy / absorb) — there the listing reads
+     * (1 + approach-halo ticks) x arrivals, never the arrivals; `getArrivals` is the
+     * reader. THROWS on a wall without the count hook (no collected-frames buffer → it
+     * would silently report 0 forever).
      * @param {Object} [tickData] — the universe.doTick() result (sample lane).
      * @returns {number}
      */
     Wall.prototype.getLiveCount = function (tickData) {
+        if (_runningProgramRemoves(this)) {
+            throw new Error(
+                '[Wall.getLiveCount] this wall REMOVES what it hits (collisionBehavior "' +
+                this.collisionBehavior + '") — getLiveCount is the zone-occupancy reader of a ' +
+                'non-removing wall, and on a removing wall it would count each frame once per ' +
+                'approach tick plus once on its kill tick. Read arrivals with ' +
+                'wall.getArrivals(tickData) → { total, delta } (the engine\'s own per-wall count).'
+            );
+        }
         var counts = Array.isArray(this.hooks) && this.hooks.indexOf('count') !== -1;
         if (!counts) {
             throw new Error(
@@ -818,6 +841,70 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
         return this._liveCount || 0;
     };
 
+    /**
+     * ARRIVALS readout: how many frames have triggered THIS wall's collision program —
+     * read from the engine's own per-wall counter, `tickData.objects[handle].count`, the
+     * contract's one read authority for an LO count (ENGINE_CONTRACT §4.3). The `count`
+     * hook compiles `set 1.count = 1.count + 1` behind the trigger, so the engine counts
+     * one per trigger event; on a removing wall (destroy / absorb) each trigger is the
+     * frame's removal, so the count IS the arrivals. Never derived from the collected
+     * frame listing (that is the padded search-rect census — see getLiveCount).
+     *
+     * Layer 1 (API): dual-lane, the same shape as getLiveCount —
+     *   getArrivals(tickData) — SAMPLE lane: read the engine count and return
+     *     `{ total, delta }`: `total` = cumulative arrivals since the wall registered,
+     *     `delta` = the change since the previously sampled TickData (this tick's
+     *     arrivals when sampled every tick). IDEMPOTENT per TickData — sampling the same
+     *     TickData twice returns the same `{ total, delta }`.
+     *   getArrivals() — READ lane: the last sample (`{ total: 0, delta: 0 }` before the
+     *     first tick).
+     *
+     * Layer 2 (physics): zero physics — a pure reader of a counter the compiled program
+     * already maintains (bench LO7); reading it moves nothing (SU1).
+     *
+     * Guards: THROWS on a wall without the count hook (the engine counter never moves →
+     * it would silently report 0 forever), and on a TickData that is not the one this
+     * wall's universe last produced (`universe._lastTickData`, the object `doTick()` returned
+     * and every tick listener receives). LO handles restart at 0 in every universe, so a
+     * TickData from another world indexes a different wall's count at the same handle; and
+     * an earlier TickData of this world would yield a wrong delta.
+     * @param {Object} [tickData] — the universe.doTick() result (sample lane).
+     * @returns {{ total: number, delta: number }}
+     */
+    Wall.prototype.getArrivals = function (tickData) {
+        var counts = Array.isArray(this.hooks) && this.hooks.indexOf('count') !== -1;
+        if (!counts) {
+            throw new Error(
+                '[Wall.getArrivals] this wall does not COUNT (collisionBehavior "' +
+                this.collisionBehavior + '", hooks ' + JSON.stringify(this.hooks || []) +
+                ') — the engine increments a wall\'s count only through the `count` hook; ' +
+                'add hooks: [\'count\'] (preset \'detector-screen\' = destroy + count).'
+            );
+        }
+        if (!this._arrivals) { this._arrivals = { td: null, total: 0, delta: 0 }; }
+        var a = this._arrivals;
+        if (tickData != null && tickData !== a.td) {
+            if (tickData !== this.universe._lastTickData) {
+                throw new Error('[Wall.getArrivals] "' + this.name + '": this is not the TickData its ' +
+                    'own universe last produced (universe._lastTickData) — it is another world\'s, ' +
+                    'where handle ' + this.lo.handle + ' is a different wall, or an earlier tick of ' +
+                    'this one. Sample the TickData this wall\'s universe.doTick() just returned. (FAIL-LOUD.)');
+            }
+            var handle = this.lo.handle;
+            var oc = tickData.objects && tickData.objects[handle];
+            if (!oc || typeof oc.count !== 'number') {
+                throw new Error('[Wall.getArrivals] "' + this.name + '": this world\'s TickData carries no ' +
+                    'objects[' + handle + '].count — every registered LargeObject is marshalled each ' +
+                    'tick, so the wall is not registered here. (FAIL-LOUD.)');
+            }
+            var total = oc.count;
+            a.delta = total - a.total;
+            a.total = total;
+            a.td = tickData;
+        }
+        return { total: a.total, delta: a.delta };
+    };
+
     /**
      * ABSORB v2 readout: the wall's live { stored, absorbedTotal, radiatedTotal } (the
      * REAL backing-frame mass ledger). Throws on a non-absorb wall. Call between ticks.
@@ -884,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.1';  // sdk/frqtl-web/package.json#version (the ONE version owner) — bound by router.test.mjs
+var CDN_SDK_VERSION = '0.6.1-p3.3';  // 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.1/dist/frqtl/compat/engine.js'
+ * // 'https://cdn.jsdelivr.net/npm/@descix/frqtl-web@0.6.1-p3.3/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

@@ -0,0 +1,42 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * device.js — the ONE rule for "this document is open on a phone".
+ *
+ *   MOBILE_DEVICE_QUERY   the media query: a coarse primary pointer (a finger, not a mouse) on a viewport no wider
+ *                         than the widest phone held in landscape (932 CSS px, the iPhone Pro Max). A tablet in
+ *                         portrait is narrower than that and counts as a phone; a touch laptop has a fine pointer
+ *                         and does not.
+ *   isMobileDevice(win)   win.matchMedia(MOBILE_DEVICE_QUERY).matches — evaluated in the window that LAYS OUT the
+ *                         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 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 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.
+ *
+ * Host-neutral ESM with no imports.
+ */
+
+/** A phone: a coarse primary pointer on a viewport no wider than a phone in landscape. */
+export const MOBILE_DEVICE_QUERY = '(pointer: coarse) and (max-width: 932px)';
+
+/**
+ * @param {{matchMedia: function(string): {matches: boolean}}} win  the window the page is laid out in
+ * @returns {boolean}
+ * @throws {TypeError} a window without matchMedia
+ */
+export function isMobileDevice(win) {
+    if (!win || typeof win.matchMedia !== 'function') {
+        throw new TypeError('[device] isMobileDevice(win) needs the window the page is laid out in (a matchMedia ' +
+            'function); got ' + (win === null ? 'null' : typeof win) + '. (FAIL-LOUD.)');
+    }
+    return win.matchMedia(MOBILE_DEVICE_QUERY).matches === true;
+}

package/dist/shim/project/index.js

@@ -13,8 +13,14 @@
  *   parseManifest, serializeManifest, manifestFor    manifest.js (THE owner of frqtl.json)
  *   RECORD_FILES, RECORD_KEYS, CHANGE_KEYS, OPS, BY,
  *   CLIP_SECONDS, CLIP_NAME, clipName, jsonText,
- *   recordFolderFaults, applyRows                    record-format.js (THE owner of the Record folder's shape and
- *                                                    of its change rows' meaning: applyRows applies them to a block)
+ *   rowFaults, recordFolderFaults, applyRows         record-format.js (THE owner of the Record folder's shape and
+ *                                                    of its change rows' shape and meaning: rowFaults checks one row,
+ *                                                    applyRows applies them to a block)
+ *
+ * The entry stands alone: it loads the parts roster (every published kind registers on import, objects/kinds.js),
+ * so applyRows can spell a 6-number rect by its kind's descriptor with nothing else imported. The roster is imported
+ * HERE, by the package door, and never by record-format.js: a scene page reaches record-format statically
+ * (RecipeContext → Record.js) and loads the roster only in its boot's modules phase, where a failed part is reported.
  *
  * PROJECT_EXPORTS is this entry's export list; a conformance test holds the module's exports equal to
  * it, and the package gate holds it equal across @descix/frqtl-web and @descix/frqtl-node.
@@ -25,11 +31,14 @@ export const PROJECT_EXPORTS = Object.freeze(['FRQTL_WEB_SPECIFIERS', 'libPathOf
     'linkProject', 'sketchProject', 'SKETCH_ENTRY', 'projectIdentity',
     'MANIFEST_FILE', 'MANIFEST_KEYS', 'normalizeManifest', 'parseManifest', 'serializeManifest', 'manifestFor',
     'RECORD_FILES', 'RECORD_KEYS', 'CHANGE_KEYS', 'OPS', 'BY', 'CLIP_SECONDS', 'CLIP_NAME', 'clipName', 'jsonText',
-    'recordFolderFaults', 'applyRows']);
+    'rowFaults', 'recordFolderFaults', 'applyRows']);
+
+// The parts roster (see above): a side-effect import, so ./project stands alone.
+import '../../frqtl/parts/index.js';
 
 export { FRQTL_WEB_SPECIFIERS, libPathOf, importMapFor, pageImportMapFor, FRQTL_WEB_HOST_SPECIFIERS } from './specifiers.js';
 export { linkProject, sketchProject, SKETCH_ENTRY } from './link.js';
 export { projectIdentity } from './identity.js';
 export { MANIFEST_FILE, MANIFEST_KEYS, normalizeManifest, parseManifest, serializeManifest, manifestFor } from './manifest.js';
 export { RECORD_FILES, RECORD_KEYS, CHANGE_KEYS, OPS, BY, CLIP_SECONDS, CLIP_NAME, clipName, jsonText,
-    recordFolderFaults, applyRows } from './record-format.js';
+    rowFaults, recordFolderFaults, applyRows } from './record-format.js';

package/dist/shim/project/parts-spelling.js

@@ -10,7 +10,8 @@
  *   spellRect(props, { kind, entryKeys, baseline }) — a 6-tuple of a field whose descriptor derives reads from it
  *       (ObjectSchema.derivedReads: Wall `z`, `depth`) is written as the 4-tuple plus each derived key whose value
  *       changed, when the entry spells any of those keys as plain properties; otherwise the 6-tuple stands. A
- *       4-tuple equal to the baseline's is not written (no literalizing an untouched expression).
+ *       4-tuple equal to the baseline's is not written (no literalizing an untouched expression). THROWS, naming the
+ *       remedy, when `kind` is not registered in this realm (no imported module defines it).
  *   spellCenter(props, { entryKeys, centerLength }) — a `center` [x, y, 0] is written as two numbers when the entry
  *       spells two; otherwise the [x, y, z] stands.
  *   captureCenter(v) — the inverse: a spelled `center` in its capture form. [x, y] → [x, y, 0] (an omitted z is 0,
@@ -31,6 +32,12 @@ function _hasSix(props) {
 /** @param {object} props @param {{ kind: string, entryKeys: function(): string[], baseline: object }} o */
 export function spellRect(props, o) {
     if (!_hasSix(props)) { return props; }
+    if (!ObjectSchema.get(o.kind)) {
+        throw new Error('[parts-spelling] the kind "' + o.kind + '" is not registered in this realm: a 6-number rect is spelled by ' +
+            'its descriptor, and a kind registers when the module that defines it is imported (the published parts register ' +
+            'with ./project; a project\'s own part, parts/' + o.kind + '.js, when its module is imported) — import the module ' +
+            'that defines it. (FAIL-LOUD.)');
+    }
     const derived = ObjectSchema.derivedReads(o.kind);
     if (!derived.length) { return props; }
     const spelled = o.entryKeys();

package/dist/shim/project/record-format.js

@@ -22,6 +22,9 @@
  *   CLIP_SECONDS         { min, max } — the length of one clip, in seconds of playback
  *   CLIP_NAME            the clip file pattern; clipName(n) → 'clip-NN.mp4' (n from 1)
  *   jsonText(v)          JSON.stringify(v, null, 2) + '\n' — every JSON file of the folder
+ *   rowFaults(row, at?) → string[]   [] for a valid change row, every fault by name otherwise — THE one shape check of
+ *                        a row (its keys, tick, name, by, op in OPS, from/to per op); recordFolderFaults, applyRows and
+ *                        serializeRecordFolder ask it, so a host checking a row before it writes or applies one asks it too
  *   recordFolderFaults(files) → string[]   [] for a complete §6 folder, every fault by name otherwise
  *   serializeRecordFolder(parts) → { files, record, clips } | { empty: true }   THE writer (Record.js calls it;
  *                        it runs recordFolderFaults on its own output and THROWS on any fault)
@@ -128,8 +131,17 @@ function _placement(v) {
 
 const MOVE_SHAPE = 'move carries from/to as ONE key, {center: [x, y, z]} or {rect: [4 numbers flat | 6 with a z-extent]}, the same key and length in both';
 
-/** The faults of one change row against its op. */
-function _rowFaults(c, at) {
+/**
+ * rowFaults(row, at?) → string[] — THE shape check of one change row: [] when valid, otherwise every fault by name.
+ * Checks the keys (exactly CHANGE_KEYS), `tick` (a whole tick ≥ 0), `name` (the declared name), `by` (one of BY),
+ * `op` (one of OPS) and `from`/`to` (strict JSON, in that op's shape; a move that moves nothing is a fault).
+ * A row alone carries no folder facts: tickRange, tick order and one shape per name's moves are recordFolderFaults'.
+ * @param {*} c the row
+ * @param {string} [at='row'] the row's label at the head of each fault (e.g. 'changes[3]')
+ * @returns {string[]}
+ */
+export function rowFaults(c, at) {
+    if (at === undefined) { at = 'row'; }
     const bad = [];
     if (!_isPlain(c)) { return [at + ' is not a change {' + CHANGE_KEYS.join(', ') + '}']; }
     const keys = Object.keys(c);
@@ -228,7 +240,7 @@ export function recordFolderFaults(files) {
                 let last = -Infinity;
                 rec.changes.forEach(function (c, i) {
                     const at = RECORD_FILES.record + ' changes[' + i + ']';
-                    _rowFaults(c, at).forEach(function (f) { bad.push(f); });
+                    rowFaults(c, at).forEach(function (f) { bad.push(f); });
                     if (!_isPlain(c)) { return; }
                     if (Number.isInteger(c.tick)) {
                         if (range && (c.tick < range[0] || c.tick > range[1])) { bad.push(at + ' at tick ' + c.tick + ' lies outside tickRange ' + JSON.stringify(range)); }
@@ -332,7 +344,7 @@ export function serializeRecordFolder(p) {
     // Check the rows as HELD, before any text: JSON.stringify writes NaN/Infinity as null and drops an undefined key,
     // so a check of the written text would read a different value from the one the Record held.
     const held = [];
-    record.changes.forEach(function (c, i) { held.push.apply(held, _rowFaults(c, 'changes[' + i + ']')); });
+    record.changes.forEach(function (c, i) { held.push.apply(held, rowFaults(c, 'changes[' + i + ']')); });
     if (held.length) { throw new Error('[record-format] a change row is not strict JSON: ' + held.join('; ') + ' (FAIL-LOUD.)'); }
     const files = {};
     files[RECORD_FILES.record] = jsonText(record);
@@ -369,12 +381,16 @@ function _centerLength(props) {
  *   fork          entry `name`'s kind becomes `to.kind` (its props are unchanged)
  * The spelling is the writer's own rule (parts-spelling.js spellRect / spellCenter: a 6-number rect beside spelled
  * `z`/`depth` keys, a two-number center), read off the block, so a block a hand changed and the rows that change
- * wrote agree: applyRows(parts.before, record.changes) is parts.after. A rect row on a kind whose descriptor derives
- * reads (Wall) asks ObjectSchema, so that kind is registered in the realm (its part module imported).
+ * wrote agree: applyRows(parts.before, record.changes) is parts.after. A 6-number rect row asks its kind's descriptor
+ * (ObjectSchema.derivedReads): the ./project entry (index.js) imports the parts roster, so every published kind is
+ * registered wherever ./project is loaded, and a scene page has registered them by its boot's modules phase; a
+ * project's own kind (a fork's parts/<Kind>.js) is registered when its module is imported. This module itself imports
+ * no part: the scene page reaches it statically (RecipeContext → Record.js), and a static barrel import here would load
+ * every part with the page module, ahead of the boot record (a failed part would then leave no boot banner).
  * THROWS, naming the row index and the offending value: a block that is not { name: [kind name, {props}] }; rows
- * that are not an array; a row recordFolderFaults would name (an op that is not one of OPS, its keys, its from/to
- * shape); a name the block does not hold (move, setDeclared, remove, fork) or already holds (add); a fork whose
- * `from` is not the entry's kind.
+ * that are not an array; a row rowFaults names (an op that is not one of OPS, its keys, its from/to shape — the
+ * faults in the error); a 6-number rect row on a kind no imported module registered; a name the block does not
+ * hold (move, setDeclared, remove, fork) or already holds (add); a fork whose `from` is not the entry's kind.
  * @param {Object<string, [string, object]>} partsBlock
  * @param {object[]} rows
  * @returns {Object<string, [string, object]>}
@@ -386,7 +402,7 @@ export function applyRows(partsBlock, rows) {
             JSON.stringify(rows) + '. (FAIL-LOUD.)');
     }
     rows.forEach(function (row, i) {
-        const faults = _rowFaults(row, 'rows[' + i + ']');
+        const faults = rowFaults(row, 'rows[' + i + ']');
         if (faults.length) { _applyFail(i, 'is not a change row: ' + faults.join('; ')); }
         const name = row.name;
         const has = Object.prototype.hasOwnProperty.call(block, name);
@@ -411,8 +427,10 @@ export function applyRows(partsBlock, rows) {
         // move / setDeclared: the row's capture-form values, spelled in the entry's own form.
         const props = JSON.parse(JSON.stringify(row.to));
         const own = entry[1];
-        spellRect(props, { kind: entry[0], baseline: row.from, entryKeys: function () { return Object.keys(own); } });
-        spellCenter(props, { entryKeys: function () { return Object.keys(own); }, centerLength: function () { return _centerLength(own); } });
+        try {
+            spellRect(props, { kind: entry[0], baseline: row.from, entryKeys: function () { return Object.keys(own); } });
+            spellCenter(props, { entryKeys: function () { return Object.keys(own); }, centerLength: function () { return _centerLength(own); } });
+        } catch (e) { throw new Error('[record-format] applyRows: rows[' + i + '] (' + row.op + ') of "' + name + '": ' + ((e && e.message) || String(e))); }
         block[name] = [entry[0], Object.assign({}, own, props)];
     });
     return block;

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/studio-landing.js

@@ -8,7 +8,10 @@
  * its error copy.
  *
  *   STUDIO_LANDING_ATTR          the <html> attribute carrying the outcome id
- *   STUDIO_LANDING_OUTCOMES      the closed table: one row per branch of STUDIO's link resolution, `{ id, means }`
+ *   STUDIO_LANDING_OUTCOMES      the closed table: one row per branch of STUDIO's link resolution, `{ id, runs, means }`;
+ *                                `runs` says whether the scene that landing opens starts on load (through STUDIO's Run
+ *                                control's own path) — true only on `ok`, a deep link that named a scene; every other
+ *                                landing opens its scene in Design, waiting for Run
  *   recordStudioLanding(root, id) writes `id` on `root` (an Element, or null to only validate); an id outside the
  *                                table THROWS — that is a defect in the writer, never a landing
  *
@@ -29,23 +32,23 @@ export const STUDIO_LANDING_ATTR = 'data-frqtl-studio-landing';
 
 /** The closed table of STUDIO deep-link landings, in the order the resolver tests them (lib/features/ide/test/studio-landing-of.test.mjs holds it). */
 export const STUDIO_LANDING_OUTCOMES = Object.freeze([
-    { id: 'refused-key',
+    { id: 'refused-key', runs: false,
       means: 'the link carries a key STUDIO does not own, or a deleted key (deep-link.js deepLinkRefusalOf): the refusal is on the deep-link strip and the opening rung opens' },
-    { id: 'conflict',
+    { id: 'conflict', runs: false,
       means: 'the link names both a walkthrough and a saved project: nothing opens' },
-    { id: 'mode-without-walkthrough',
+    { id: 'mode-without-walkthrough', runs: false,
       means: 'the link names a mode and no walkthrough: nothing opens' },
-    { id: 'unknown-walkthrough',
+    { id: 'unknown-walkthrough', runs: false,
       means: 'the linked walkthrough is not in the walkthrough registry (walkthroughById): nothing opens' },
-    { id: 'unknown-mode',
+    { id: 'unknown-mode', runs: false,
       means: 'the linked mode is not one the linked rung declares (walkthroughModes): nothing opens' },
-    { id: 'project-unreadable',
+    { id: 'project-unreadable', runs: false,
       means: 'the linked saved project is present but its folder is refused by the load: nothing opens' },
-    { id: 'project-not-found',
+    { id: 'project-not-found', runs: false,
       means: 'no saved project of the linked name in this browser: nothing opens' },
-    { id: 'ok',
-      means: 'the linked walkthrough (in the linked mode, else its default) or saved project resolved and was handed to STUDIO\'s selection path' },
-    { id: 'first-contact',
+    { id: 'ok', runs: true,
+      means: 'the linked walkthrough (in the linked mode, else its default) or saved project resolved and was handed to STUDIO\'s selection path; the scene starts on load' },
+    { id: 'first-contact', runs: false,
       means: 'no STUDIO deep link: the walkthrough registry\'s opening rung opens' },
 ].map(Object.freeze));