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

package/CLAUDE.md

@@ -2,7 +2,7 @@
 
 A discrete cellular-automata physics engine (compiled Rust → WASM) for node: the same modules as
 `@descix/frqtl-web` (one source, built twice), plus the node engine door `bootNode` and the hosted eyes.
-`0.6.1-p3.1` (npm dist-tag `next`). Node ≥ 22.12.
+`0.6.1-p3.2` (npm dist-tag `next`). Node ≥ 22.12.
 
 ## Install
   npm install @descix/frqtl-node

package/README.md

@@ -4,7 +4,7 @@ FRQTL for node: a discrete cellular-automata physics engine (compiled Rust → W
 local per-pixel rules — a frame moves one pixel per tick, single occupancy, momentum — rather than force
 equations. Interference, blackbody spectra and atom-like binding emerge from the automaton.
 
-`0.6.1-p3.1` (npm dist-tag `next`). Node ≥ 22.12.
+`0.6.1-p3.2` (npm dist-tag `next`). Node ≥ 22.12.
 
 ## Install
 
@@ -31,7 +31,7 @@ const tick = u.doTick();                                         // TickData: fr
 | `.` | the parts (`Wall`, `SphereEmitter`, `Tunnel`, `FrqtlVision`, …), `bootNode`, the engine accessors (`engine`, `engineState`), the capture contracts (`FrqtlCapture`, `RenderStages`, `FieldBuilder`, `CaptureEnvelope`) and `validateRendererProvider` |
 | `./eyes` | `openHostedEyes` — a `composite` still through the REAL renderer, in a managed headless browser (pulls the pinned `playwright`) |
 | `./parts`, `./parts/*` | the parts barrel; one part = one file |
-| `./project` | `FRQTL_WEB_SPECIFIERS`, `libPathOf`, `importMapFor`, `pageImportMapFor`, `FRQTL_WEB_HOST_SPECIFIERS`, `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` |
+| `./project` | `FRQTL_WEB_SPECIFIERS`, `libPathOf`, `importMapFor`, `pageImportMapFor`, `FRQTL_WEB_HOST_SPECIFIERS`, `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`, `rowFaults`, `recordFolderFaults`, `applyRows` (stands alone: no other import is needed) |
 | `./registry` | the walk-through rungs, the showcase roster, the scene list (`sceneGroups`), `projectOf`, a showcase tile's link (`showcaseHref(row)` relative to the serving site, `showcaseUrl(row)` absolute on `SHOWCASE_SITE.origin`; `row` is an element of the same imported `EXHIBITS`, and the link carries the row's effective mode on a multi-mode rung), and how STUDIO resolved the link it opened with (`STUDIO_LANDING_ATTR` on `<html>`, a `STUDIO_LANDING_OUTCOMES` id) |
 | `./kinds` | `registerKind`, `kindNamed`, `kindOf`, `registeredKinds` |
 | `./host-view` | `declareHostView`, `HOST_VIEW_OUTCOMES`, `CONTRACT_VIOLATIONS`, `HOST_SDK_SCRIPT` — the DeSciX host-view declarer (pure: a node test can drive a call site with a stub SDK) |

package/dist/dist-manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "@descix/frqtl-node",
-  "version": "0.6.1-p3.1",
+  "version": "0.6.1-p3.2",
   "files": {
     "eyes/index.js": "b3563421030bb7fdd277eb697959fbe9107463cbb5478160edc7d887daa67be3",
     "fat/pkg-node/egpt_wasm.js": "5e6af1f6725c93c0e9ad7386f1785cbe639ce596a4caa19ca85729c1f2bea04d",
@@ -113,7 +113,7 @@
     "frqtl/parts/FrqtlControlOverlay.js": "f862b1529265224aa96878b56b0c1c6e65683ba3fd6b517df86e17e92147f9c4",
     "frqtl/parts/FrqtlControlsPanel.js": "792d03dea218bdc335ba7e04362be620edbfa331bed9de087d61942299728cc1",
     "frqtl/parts/FrqtlVision.js": "118d0874249fa55783b196fd01297b3347951267a4add93381433a72c46e8622",
-    "frqtl/parts/GraphingDetectorWall.js": "83aba36a6a6c15f92c99bbe5d7e63b12b38e07be65e02e89020c065514ef5b3d",
+    "frqtl/parts/GraphingDetectorWall.js": "a2fef24c2ef00416792c4b46a09c9544601e45e84593fa2287d2311f27a1bcee",
     "frqtl/parts/LargeObject.js": "d6cae738b30965f3eba4be4399fb4410f17afc3267b51e3ad9e1ba7423e17922",
     "frqtl/parts/LightColor.js": "8637e5a09bbad3a4fdd2034ccb44dfc1fda743e29b12b4c685a64b9e1df28daa",
     "frqtl/parts/LiveChart.js": "8bd0b862d2f7a4e818ae9cfc47e5e0f56eb97ea0a00fb836bba3f2374c12a1ce",
@@ -126,7 +126,7 @@
     "frqtl/parts/SphereEmitter.js": "645664f5a20924b777d9b4ad6fef6338e7de251d62c7f8a4c93e6b0f97b47d4a",
     "frqtl/parts/Trace.js": "f9d91bb9435bc5fabfd7bfdbfbf3f3ae34e2338090251d9e9d6c11abc2ed25fb",
     "frqtl/parts/Tunnel.js": "66bfca3d3d88ebf9a8cb7aa248b92cfc7d78a278449830b03e6b2700a21df891",
-    "frqtl/parts/Wall.js": "7dcb520daee3facad8698b363bb49557003439dc5841706b105bd1acabc2e0bf",
+    "frqtl/parts/Wall.js": "34f8e4f5143925b42e42561eb54e93b0c1244debeb5c07a914beba3e8c4c75fd",
     "frqtl/parts/index.js": "70b8e227e09663889f4c7942d385f843d977579765723f829880fd6e9868ac53",
     "frqtl/scenes/absorbing-wall-3d.js": "722bb433142833f03150052b95039686aba0d9db510a5ff13fad95b5f17e0cf8",
     "frqtl/scenes/absorbing-wall.js": "0a47ca64e56481841339cd5882cf0e54ec7c14d87a4306d016ead1ff26591197",
@@ -166,12 +166,13 @@
     "shim/engine/artifact-shell.js": "f23c327500f8174b12d464868f6ec9c1701e7a9a5faa1c43a2ddafc3191dc38c",
     "shim/engine/boot-phases.js": "c6e12e12824bcf6f1a289f46e41c898a5416c80c131594525145aae9a3eefbfa",
     "shim/engine/engine-stack-boot.js": "0abf57dcff2ca2bb025c787a17875d49d54d9218ac08c78cb9c678dbb6118d08",
-    "shim/engine/router.js": "62a1995871557536f48903eec14849b135f7d5d5e68c77139b61289a405072b3",
+    "shim/engine/router.js": "1c8bed954aecfcd06d1344051d8489f0f040967f9d0879ec7e7a0d1e58045d2c",
     "shim/engine/site-graph.js": "b0d2569c67516d08bba17a152d5d3bfa0b036666eda7f11df74b4d68854e1b93",
     "shim/experiment-frame/index.js": "5a0219aaa225d8f808c405b08623ce85ada37d83fb4f55f983db3303e431e47f",
     "shim/expr/ast-schema.js": "4f1133b887639bbd86fab976292323bf4a955cdc873ff7ca8e8a8eb3b416923f",
     "shim/field-descriptor/index.js": "6647d57d1523519114adc0a5cb66335ec5121c39ab294b9c97bdfb9e5d7f61e0",
     "shim/frame-data/index.js": "df6957b0b4a8e0ee0035bc970647b90089b421ae7f05911cc047d48457164be6",
+    "shim/host/device.js": "85470e7c787398cb91516b724e884ac50104d56330ba7ff876308b6fb4b7b532",
     "shim/host/host-view.js": "feec2f5fdc318e75cd01768c24891f85d2694a269696fcfffd9567d31983cf43",
     "shim/host/index.js": "fade4b171218965570aa2e67e841920ebb3d972ff15e1cfa0394fd3fa123d82c",
     "shim/index.js": "96165c6161ffddbace0be0cde0b3a83943298531537dd2cc9c6e281b8274ff19",
@@ -197,15 +198,15 @@
     "shim/page-params/index.js": "c58732b8127da8c2b4ecfd922bf46a6c9a5e9ab7017f41c095a6ec937011f0fa",
     "shim/project/fork.js": "07555f24c7e6d1bbe723853bc09ad570b9cd36cef248a07e98e7398d41ac70da",
     "shim/project/identity.js": "8d3e0bb9df75eecf7d11a1ea7948ff66c559973a891574d0b208c9e8f8faf504",
-    "shim/project/index.js": "ba0d7812445aad52c36d6dd806e2d8c6b87d43e4d7c4494e9c0bfa9da8503a03",
+    "shim/project/index.js": "5121dd4c18aeea190d2a998fa7a13f86cb36b13cf043f8c549963c1ae51ba26e",
     "shim/project/link.js": "0e3fc878bc45d9916baacd7cf129687ec6e82efd4f6f5036e4697180b3d0f87a",
     "shim/project/manifest.js": "442267af07ae1b977ff6aeaca49d98ce82b77f548cfdd1ed0f258b3429d75f31",
     "shim/project/node-specifier-hook.mjs": "8601edf762bd9cd011632bc681d0589dfc77368cda0e994125d0eb123fea89d0",
     "shim/project/parts-module.js": "b08e0149f086640692e1b2ff8e0d7ae0379c2bc934a0891418de5c2b8c0e8e60",
-    "shim/project/parts-spelling.js": "f43c356d8c08077a76190cb88bad4daa4280c112d120ee478ba67993c77c41ea",
+    "shim/project/parts-spelling.js": "4cc7b8a2f0aa1f3ad4c1c3cf15f74b2860a94ae2214dbef78d31c85ff8916cfe",
     "shim/project/parts-writer.js": "121fa67261d6f366190c9ac4961fceed2f26ca7f35cf3fbffc767829afc69978",
     "shim/project/read-text.js": "b89bd70e3a271e1f42c8ce9427a20cdd9a4c4c9c31b64c49ff1f56b095620136",
-    "shim/project/record-format.js": "95cbb99d294e66c94f9f1921664cd932649c6d6b187b17928b8fb4b955ca880f",
+    "shim/project/record-format.js": "87d5cc2eae8ff600db1db58a0e0047819f7c9839ff702acdedc366c7647eb0ef",
     "shim/project/register-node.mjs": "9b408da7dc1b11d16237cd62caca281c823ea80173d386ad35e41ea17c34857f",
     "shim/project/specifiers.js": "288e5e06e53b873449190f6f85855177a72e52623bd11eef016acafb8095d829",
     "shim/registry/copy-gate.js": "cfbf52669c849b8837b326f2743458f1ead0720cad51a6c6d409c9bd6c7f9495",
@@ -214,7 +215,7 @@
     "shim/registry/scene-roster.js": "318fe373f71b1c58d05425693f2fad4bd5368f6095b65817c6d637430a0bfb73",
     "shim/registry/scene-source.js": "c9c4b48c24d4b1ebee1549a7891a1ba708909b94b9403ce28eefbd902cacf49f",
     "shim/registry/showcase-link.js": "daf5c1426aeb3c578bace5e0edea9ba2538cd82336d2cdc944e5fed6decd7551",
-    "shim/registry/studio-landing.js": "c34c9e7e77087c2bfa6be9c34dafedb1e3256e92eb1aeb629b7f7182cd2edf9f",
+    "shim/registry/studio-landing.js": "bd81ad9333332de4a29b3121f963edd354450c75c97f4f43170a98c2dcceb7f3",
     "shim/registry/walkthrough.js": "8f8b6f59e9e81c67c9c62f8fb271eee2e4d6e1fba6e116b227a2f1e3f9930230",
     "shim/render-state/apply.js": "94a9e60cb1722c9a82aa00f2f161fd65e6f438147333856a786e42a4ad5b7064",
     "shim/render-state/index.js": "72a6a3dcd8037893cb8fbd7ef32b126770e7efaec70847f8e4f2915ddb690b43",

package/dist/frqtl/parts/GraphingDetectorWall.js

@@ -36,7 +36,7 @@
  *     colour washed under the bins, so an un-hit face still reads as a plate and
  *     intensity rises monotonically from empty through every bin.
  *
- * Readouts: `getCollisionHistogram()` / `resetHistogram()` / `getLiveCount()` —
+ * Readouts: `getCollisionHistogram()` / `resetHistogram()` / `getArrivals()` —
  * inherited from `Wall`, UNCHANGED. `heatCanvas()` returns the ferry canvas.
  *
  * ── ESTIMATION BEFORE RUNNING: when will this plate have counted anything? ───

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.

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.2';  // 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.2/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/host/device.js

@@ -0,0 +1,38 @@
+/* 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 two 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.
+ * 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/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));
 

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.2 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.2/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.2",
   "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": {