@descix/frqtl-node 0.6.1-p2.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-p2.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/LICENSE.md

@@ -389,7 +389,7 @@ For GUIs, use an "About box" with similar information.
 
 **The Original License is not displaced.** Nothing in this Agreement relieves You of any obligation the Original License imposes on Pre-existing Material. By way of example, if Pre-existing Material is licensed under the Mozilla Public License, its file-level copyleft, notice and source-availability obligations continue to bind You for that material; this Agreement neither absolves You of them nor extends them to Covered Works.
 
-**This Agreement is not displaced.** No Original License shall be read to invalidate, override, relicense or extend its terms to any Covered Work or Community IP. If You combine, link or otherwise mix a Covered Work with Pre-existing Material whose Original License would, by its terms, purport to govern the combination or require the Covered Work to be licensed under that Original License (by way of example, the GNU General Public License), You are in breach of this Agreement from the moment of the combination: Your license under this Agreement terminates as to that combination under Clause 7, You lose the protections this Agreement affords Members with respect to it, and the Original License shall not be read to apply to the Covered Work or Community IP, whose terms remain those of this Agreement.
+**This Agreement is not displaced.** No Original License shall be read to invalidate, override, relicense or extend its terms to any Covered Work or Community IP. If You combine, link or otherwise mix a Covered Work with Pre-existing Material whose Original License would, by its terms, purport to govern the combination or require the Covered Work to be licensed under that Original License (by way of example, the GNU General Public License), You are in breach of this Agreement from the moment of the combination: Your license under this Agreement terminates as to that combination under Clause 7 of the DCSL (Section 3.1), You lose the protections this Agreement affords Members with respect to it, and the Original License shall not be read to apply to the Covered Work or Community IP, whose terms remain those of this Agreement.
 
 **Marking.** An adopter that places this Agreement in a collection containing Pre-existing Material shall place it within, or clearly identify, the directories or files it covers, so that no Pre-existing Material is represented as licensed under this Agreement.
 

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-p2.1` (npm dist-tag `next`). Node ≥ 22.12.
+`0.6.1-p3.2` (npm dist-tag `next`). Node ≥ 22.12.
 
 ## Install
 
@@ -31,11 +31,11 @@ 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` |
+| `./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) |
-| `./site-graph` | `SITE_GRAPH_DIR`, `SITE_BUILD_ATTR`, `SITE_BUILD_ID_RE`, `STATIC_APP_PAGE`, `HOST_PROVIDED_ATTR` — the static site's shape (graph directory, build-stamp attribute, build id pattern, IDE entry page, the attribute declaring a file host-provided), for a reader of a served site (both packages) |
+| `./site-graph` | `SITE_GRAPH_DIR`, `SITE_BUILD_ATTR`, `SITE_BUILD_ID_RE`, `siteBuildStampOf`, `STATIC_APP_PAGE`, `HOST_PROVIDED_ATTR`, `SITE_PLACEMENTS`, `SITE_ENTRY_PAGES`, `isSiteEntry`, `siteGraphFaults` — the static site's shape (graph directory, build-stamp attribute, build id pattern and its reader, IDE entry page, the attribute declaring a file host-provided, the graph directory of each placed package, the entry pages) and the rule that a served graph is the placed releases' bytes, for a reader of a served site (both packages) |
 | `./register` | installs the resolve hook for a sketch's `@descix/frqtl-web/...` imports (`node --import @descix/frqtl-node/register`) |
 | `./shim/controls/registry.js`, `./shim/render/sun-look.js`, `./compat/renderer/display-slot.js`, `./compat/renderer/orbit-bag.js`, `./objects/setup/_collisionMatrixLanes.js`, `./compat/engine.js` | the six non-part modules a scene may import (the rows of `FRQTL_WEB_SPECIFIERS`) |
 | `./objects/objects/tagger.js`, `./objects/schema/index.js`, `./shim/render/heat-colormap.js`, `./objects/schema/valueNormalizer.js`, `./objects/objects/Box.js`, `./objects/objects/QuantumEmitter.js`, `./shim/expr/ast-schema.js`, `./objects/objects/actionCompiler.js`, `./objects/v1-replacements.js`, `./objects/objects/slitLinerScatter.js`, `./objects/setup/setupSphereEmitter3D.js`, `./objects/objects/directedRedirectProgram.js`, `./compat/renderer/lo-drawn-center.js`, `./objects/setup/setupTunnelPointExit.js`, `./objects/constants/WallBehaviors.js`, `./objects/objects/absorbRadiation.js`, `./objects/geometry/SlabFace.js` | the 17 part-internal modules a forked part file imports (the `tier: 'part-internal'` rows of `FRQTL_WEB_SPECIFIERS`): not a scene API — the linker admits them only from a `parts/*.js` file — and they move with the parts |

package/dist/dist-manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "@descix/frqtl-node",
-  "version": "0.6.1-p2.1",
+  "version": "0.6.1-p3.2",
   "files": {
     "eyes/index.js": "b3563421030bb7fdd277eb697959fbe9107463cbb5478160edc7d887daa67be3",
     "fat/pkg-node/egpt_wasm.js": "5e6af1f6725c93c0e9ad7386f1785cbe639ce596a4caa19ca85729c1f2bea04d",
@@ -40,7 +40,7 @@
     "frqtl/node-entry.js": "a401039b4fcf53ac620edbd80985aa4448122f2e3caaeaf4d5595f5e9d512b60",
     "frqtl/objects/FrqtlApp.js": "e3232b09eb576427df2a52393a5603b4c084d6edba5667b03afb161fd6d76b9b",
     "frqtl/objects/ObjectFactory.js": "a8f050ce61b7ab9c9b4f81e9eeaebf05c3cc0b532c741ce93d6e952489772b11",
-    "frqtl/objects/RecipeContext.js": "c8614d30b785b333c44a59f0a6bdd15a595dd0023f85ef9385f40eda5802eba8",
+    "frqtl/objects/RecipeContext.js": "4d53e1d8a48f4567aeb882abac6f46cd649a51a3af4b543a6bec7ce74e77d7a8",
     "frqtl/objects/collectors/DataCollector.js": "8736d6cb77eec36ce2adcf2bc3b0d2436eeb70a73b77182ff053efdc6ca071df",
     "frqtl/objects/constants/WallBehaviors.js": "a05c6e06923962e2cc2cf7204131e5d20bf83c5c8e85fbb13867872040345e40",
     "frqtl/objects/geometry/SlabFace.js": "847921b124d3bc1692e88c363c087d392a1baa7c652a3a61e381d0f8a8342e57",
@@ -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": "2924f9dbdd690fc8703e1b3ad65900c323219919da1f838112513aa64e8e6bda",
-    "shim/engine/site-graph.js": "e787c875310ac6ca374c71ae41064b822d8e14ba59f357e7c71b2dcf8699dc70",
+    "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,14 +198,15 @@
     "shim/page-params/index.js": "c58732b8127da8c2b4ecfd922bf46a6c9a5e9ab7017f41c095a6ec937011f0fa",
     "shim/project/fork.js": "07555f24c7e6d1bbe723853bc09ad570b9cd36cef248a07e98e7398d41ac70da",
     "shim/project/identity.js": "8d3e0bb9df75eecf7d11a1ea7948ff66c559973a891574d0b208c9e8f8faf504",
-    "shim/project/index.js": "81d1a5d84c8bd5f31de8d9849d385509a73582e2ec6db4f779b018fe1b25404f",
+    "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": "4cc7b8a2f0aa1f3ad4c1c3cf15f74b2860a94ae2214dbef78d31c85ff8916cfe",
     "shim/project/parts-writer.js": "121fa67261d6f366190c9ac4961fceed2f26ca7f35cf3fbffc767829afc69978",
     "shim/project/read-text.js": "b89bd70e3a271e1f42c8ce9427a20cdd9a4c4c9c31b64c49ff1f56b095620136",
-    "shim/project/record-format.js": "b680c3752f20535c08be832c6808fae000c2d2325f8caee57f98351043d091be",
+    "shim/project/record-format.js": "87d5cc2eae8ff600db1db58a0e0047819f7c9839ff702acdedc366c7647eb0ef",
     "shim/project/register-node.mjs": "9b408da7dc1b11d16237cd62caca281c823ea80173d386ad35e41ea17c34857f",
     "shim/project/specifiers.js": "288e5e06e53b873449190f6f85855177a72e52623bd11eef016acafb8095d829",
     "shim/registry/copy-gate.js": "cfbf52669c849b8837b326f2743458f1ead0720cad51a6c6d409c9bd6c7f9495",
@@ -213,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/objects/RecipeContext.js

@@ -74,6 +74,7 @@ import { ObjectSchema } from './schema/index.js';
 import { kindOf } from './kinds.js';
 import { linkProject } from '../../shim/project/link.js';
 import { patchParts, PARTS_EXPORT, entryKeys, entryLiteral } from '../../shim/project/parts-writer.js';
+import { spellRect, spellCenter, captureCenter } from '../../shim/project/parts-spelling.js';
 import { moduleOfKind, PARTS_SPECIFIER } from '../../shim/project/parts-module.js';
 import { forkPartText, FORK_REFUSED } from '../../shim/project/fork.js';
 import { readText } from '../../shim/project/read-text.js';
@@ -347,47 +348,22 @@ import { Record, openRecordOf } from './record/Record.js';
     var _JSON = function (v) { return JSON.stringify(v); };
 
     /**
-     * Spell a touched rect in the entry's OWN form (architect z addendum). A 6-tuple rect of a kind 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 (entryKeys); otherwise the
-     * 6-tuple stands. A 4-tuple equal to the baseline's is not written (no literalizing an untouched expression).
-     * Mutates and returns `props`.
+     * Spell a touched value in the entry's OWN form, reading the form off the held TEXT: the rule is
+     * lib/shim/project/parts-spelling.js spellRect / spellCenter (applyRows asks the same rule of a parts block).
+     * Each mutates and returns `props`.
      */
     function _spell(text, name, kind, props, baseline) {
-        var derived = ObjectSchema.derivedReads(kind);
-        if (!derived.length) { return props; }
-        var spelled = entryKeys(text, name);
-        var R4 = ObjectSchema.RECT_TUPLE[4], R6 = ObjectSchema.RECT_TUPLE[6];
-        Object.keys(props).forEach(function (f) {
-            var v = props[f];
-            var rows = derived.filter(function (d) { return d.field === f && d.tuple === 6 && spelled.indexOf(d.name) !== -1; });
-            if (!rows.length || !Array.isArray(v) || v.length !== 6) { return; }
-            var b = Array.isArray(baseline[f]) && baseline[f].length === 6 ? baseline[f] : null;
-            var four = R4.map(function (k) { return v[R6.indexOf(k)]; });
-            if (b && _JSON(four) === _JSON(R4.map(function (k) { return b[R6.indexOf(k)]; }))) { delete props[f]; }
-            else { props[f] = four; }
-            rows.forEach(function (d) {
-                var nv = v[R6.indexOf(d.key)];
-                if (!b || nv !== b[R6.indexOf(d.key)]) { props[d.name] = nv; }
-            });
-        });
-        return props;
+        return spellRect(props, { kind: kind, baseline: baseline, entryKeys: function () { return entryKeys(text, name); } });
     }
 
-    /**
-     * Spell a touched `center` in the entry's OWN arity: two numbers when the entry
-     * spells two (a literal, or an array expression — entryLiteral's `length`) and the live z is 0; otherwise the
-     * live [x, y, z] (an entry spelled three, a 3D hand off z 0, an entry whose center is not an array). The
-     * read-back (_verifyWritten) guards every case. Mutates and returns `props`.
-     */
     function _spellCenter(text, name, props) {
-        var v = props.center;
-        if (!Array.isArray(v) || v.length !== 3 || v[2] !== 0) { return props; }
-        if (entryKeys(text, name).indexOf('center') === -1) { return props; }
-        var r = entryLiteral(text, name, 'center');
-        var n = r.literal ? (Array.isArray(r.value) ? r.value.length : null) : r.length;
-        if (n === 2) { props.center = [v[0], v[1]]; }
-        return props;
+        return spellCenter(props, {
+            entryKeys: function () { return entryKeys(text, name); },
+            centerLength: function () {
+                var r = entryLiteral(text, name, 'center');
+                return r.literal ? (Array.isArray(r.value) ? r.value.length : null) : (r.length === undefined ? null : r.length);
+            }
+        });
     }
 
     /**
@@ -403,8 +379,8 @@ import { Record, openRecordOf } from './record/Record.js';
         Object.keys(written).forEach(function (k) {
             var r = entryLiteral(text, name, k);
             decl[k] = r.literal ? r.value : undefined;
-            // A two-number center declares z 0 (the reading placeDeclaredAt gives an omitted z).
-            if (k === 'center' && Array.isArray(decl[k]) && decl[k].length === 2) { decl[k] = decl[k].concat([0]); }
+            // A two-number center declares z 0: read it in its capture form through the one inverse.
+            if (k === 'center' && Array.isArray(decl[k]) && decl[k].length === 2) { decl[k] = captureCenter(decl[k]); }
         });
         function refuse(k, declared, liveV) {
             refused.push({ op: 'set', name: name, key: k, reason: 'the written text declares ' + _JSON(declared) + ' but the live object is ' +
@@ -651,8 +627,9 @@ import { Record, openRecordOf } from './record/Record.js';
      * `center` patch sets where the entry STARTS. The loop's run state is kept. REFUSES (throws) while a hand
      * made since the last toSketch is unwritten (write it first: await exp.toSketch()), and a `name` patch (the
      * key is the name). `from` and `to` are the patched keys' capture (ObjectSchema.captureProps) before and after the
-     * re-run — one form on both sides (a z-slab wall's rect is 6 numbers even when the patch typed 4); the patch as
-     * typed is in `files`. With a Record open, its `setDeclared` row carries the same `from`/`to`, written after the re-run.
+     * re-run — one form on both sides (a z-slab wall's rect is 6 numbers even when the patch typed 4). The patch is
+     * written in the entry's own spelling (a rect beside `z`/`depth` as 4 numbers plus those keys; a `center` in the
+     * arity the entry spells, three numbers when z is not 0), as a hand's is. With a Record open, its `setDeclared` row carries the same `from`/`to`, written after the re-run.
      */
     RecipeContext.prototype.setDeclared = async function (name, patch, opts) {
         _requireWorld(this);
@@ -696,7 +673,10 @@ import { Record, openRecordOf } from './record/Record.js';
             from[k] = live[k] === undefined ? null : live[k];
         });
         var entry = this._project.entry;
+        // The patch is written in the entry's own spelling, as a hand's is (toSketch's order: rect, then center).
         var spelled = _spell(this._project.files[entry], name, kind, _plain(patch), live);
+        if (Array.isArray(spelled.center)) { spelled.center = captureCenter(spelled.center); }
+        _spellCenter(this._project.files[entry], name, spelled);
         var r = patchParts(this._project.files[entry], [{ op: 'set', name: name, props: spelled }], { entry: entry });
         if (r.refused.length) {
             throw new Error('[RecipeContext.setDeclared] the sketch text refused the patch: ' +
@@ -716,7 +696,7 @@ import { Record, openRecordOf } from './record/Record.js';
             runner.cameraControl.setOrbit(pose);
             kept.push('cameraPose');
         }
-        // `to` is what the re-run declared, in the capture form `from` is in (the patch as typed is in the text).
+        // `to` is what the re-run declared, in the capture form `from` is in (the text holds the entry's spelling).
         var rebuilt = null;
         this._parts.forEach(function (row, o) { if (row.key === name) { rebuilt = o; } });
         if (!rebuilt) {

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

@@ -35,9 +35,9 @@
 
 'use strict';
 
-// The static site's shape (graph dir, build stamp, build id, entry page) — owned by site-graph.js, imported from
-// there by every consumer; the router uses them and does not re-export them.
-import { SITE_GRAPH_DIR, SITE_BUILD_ATTR, SITE_BUILD_ID_RE, STATIC_APP_PAGE } from './site-graph.js';
+// The static site's shape (graph dir, build stamp, build id, entry page, package placements) — owned by site-graph.js,
+// imported from there by every consumer; the router uses them and does not re-export them.
+import { SITE_GRAPH_DIR, SITE_BUILD_ATTR, SITE_BUILD_ID_RE, STATIC_APP_PAGE, SITE_PLACEMENTS } from './site-graph.js';
 
 // ── Path profiles ────────────────────────────────────────────────────────────
 //
@@ -152,8 +152,8 @@ 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-p2.1';  // sdk/frqtl-web/package.json#version (the ONE version owner) — bound by router.test.mjs
-var CDN_MATH_SDK_VERSION = '0.3.2';  // sdk/egpt-math-sdk/package.json#version — bound by router.test.mjs; bumped with each npm publish
+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
 
 /**
  * The jsdelivr dist root of @descix/frqtl-web at `version` — the ONE spelling of the package's CDN URL.
@@ -270,39 +270,65 @@ var CDN_PROFILE = buildCdnProfile(CDN_BASE);
 // THE DELIBERATE DIVERGENCE FROM CDN_PROFILE (design §A.3 / §E flag 4):
 // CDN_PROFILE's math + notebook bases are hardwired CROSS-ORIGIN at CDN_MATH_BASE; the
 // static-site semantic is "everything self-contained under ONE origin prefix": the math SDK
-// is co-served at graphBase + '/egpt-math-sdk/...' and the curated notebooks ride the
-// frqtl-web dist's OWN copy at graphBase + '/notebooks'. A DISTINCT profile here is the
+// is co-served at its SITE_PLACEMENTS directory under graphBase and the curated notebooks ride the
+// frqtl-web dist's OWN copy at '<its placement>/notebooks'. A DISTINCT profile here is the
 // correct DRY call — the SAME justification that keeps CDN_PROFILE distinct from DIST_PROFILE.
 //
-// buildStaticProfile(graphBase, entryBase) — every GRAPH key anchors at `graphBase`; the
-// general 'experiments/' key (the experiment ENTRY pages STUDIO/GYM frame) anchors at
-// `entryBase`. Both are required: a host whose entries and graph share one directory passes
+// buildStaticProfile(graphBase, entryBase) — every GRAPH key anchors at its package's placement
+// under `graphBase` (site-graph.js::SITE_PLACEMENTS — the directory fact; the router stays the URL
+// authority); the general 'experiments/' key (the experiment ENTRY pages STUDIO/GYM frame) anchors
+// at `entryBase`. Both are required: a host whose entries and graph share one directory passes
 // the same base twice.
+
+// The two packages the static profile places (site-graph.js::SITE_PLACEMENTS rows); router.test.mjs binds them to the
+// sdk/*/package.json names and to the CDN bases above. The CDN URLs stay literal: G-PIN (scripts/test/cdn-pins.test.mjs)
+// reads them as text.
+var FRQTL_WEB_PACKAGE_NAME = '@descix/frqtl-web';
+var MATH_SDK_PACKAGE = '@descix/egpt-math-sdk';
+
+/**
+ * The URL of `pkg`'s placement under `graphBase` (no trailing slash). THROWS for a package no
+ * SITE_PLACEMENTS row places.
+ * @param {string} graphBase
+ * @param {string} pkg
+ * @returns {string}
+ */
+function placedBase(graphBase, pkg) {
+    var row = SITE_PLACEMENTS.find(function (r) { return r.package === pkg; });
+    if (!row) {
+        throw new Error('[engineRouter] no site-graph.js::SITE_PLACEMENTS row places ' + pkg + ' (rows: ' +
+            SITE_PLACEMENTS.map(function (r) { return r.package; }).join(', ') + ').');
+    }
+    return row.dir ? graphBase + '/' + row.dir : graphBase;
+}
+
 function buildStaticProfile(graphBase, entryBase) {
     if (!graphBase || !entryBase) {
         throw new Error('[engineRouter] buildStaticProfile(graphBase, entryBase) needs both bases (got ' +
             JSON.stringify(graphBase) + ', ' + JSON.stringify(entryBase) + ') — the graph and the entry ' +
             'pages are anchored separately; a co-served host passes the same base twice.');
     }
+    var webBase = placedBase(graphBase, FRQTL_WEB_PACKAGE_NAME);
+    var mathBase = placedBase(graphBase, MATH_SDK_PACKAGE);
     return {
         // THE package root: the GRAPH (immutable per build) at its lib-identity placement.
-        '__frqtlRoot':            graphBase + '/',
-        'assets/models/':         graphBase + '/js/models/',
+        '__frqtlRoot':            webBase + '/',
+        'assets/models/':         webBase + '/js/models/',
         // The experiment pages are ENTRIES: resolve('experiments/{id}/index.html') is the fixed page,
         // which itself points into the graph.
         'experiments/':           entryBase + '/experiments/',
         // Math + notebook lanes anchored SAME-ORIGIN into the co-served payload —
         // the deliberate divergence from CDN_PROFILE. See the factory docstring.
-        '__mathSdkUrl':           graphBase + '/egpt-math-sdk/index.js',
-        '__mathWasmUrl':          graphBase + '/egpt-math-sdk/wasm/egpt_math_sdk_wasm_bg.wasm',
-        '__mathWasmModuleUrl':    graphBase + '/egpt-math-sdk/wasm/egpt_math_sdk_wasm.js',
+        '__mathSdkUrl':           mathBase + '/index.js',
+        '__mathWasmUrl':          mathBase + '/wasm/egpt_math_sdk_wasm_bg.wasm',
+        '__mathWasmModuleUrl':    mathBase + '/wasm/egpt_math_sdk_wasm.js',
         '__mathBackend':          'wasm-math',
         // Notebooks come from the frqtl-web dist's OWN copy (build.js copyDir
         // lib/notebooks → dist/notebooks) — NOT under egpt-math-sdk (design §A.3/§B.1).
-        '__notebookBase':         graphBase + '/notebooks',
+        '__notebookBase':         webBase + '/notebooks',
         // Vendor import-map root — frqtl-web's OWN dist/vendor/ (same as CDN, self-
         // sufficient), just same-origin instead of jsdelivr.
-        '__vendorBase':           graphBase + '/vendor'
+        '__vendorBase':           webBase + '/vendor'
     };
 }
 
@@ -500,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-p2.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/engine/site-graph.js

@@ -1,25 +1,35 @@
 /* Copyright 2023-2026 by Essam Abadir */
 
 /**
- * site-graph.js — the shape of a static FRQTL site: the names a site's documents carry and the
- * directory its build-stamped graph sits in. The ONE owner and the ONE import door of each: lib/shim/engine/router.js
- * and every other consumer import them from here (the router never re-exports them), and a node consumer that reads a SERVED
- * site (a publisher's gate) imports them through the package export `@descix/frqtl-web/site-graph`
- * (or `@descix/frqtl-node/site-graph`), never typing them.
+ * site-graph.js — the shape of a static FRQTL site: the names a site's documents carry, the directory its
+ * build-stamped graph sits in, which published package owns which part of that graph, and the ONE rule that says
+ * whether a served graph is those packages' bytes. The ONE owner and the ONE import door of each:
+ * lib/shim/engine/router.js and every other consumer import them from here (the router never re-exports them), and a
+ * node consumer that reads a SERVED site (a publisher's gate) imports them through the package export
+ * `@descix/frqtl-web/site-graph` (or `@descix/frqtl-node/site-graph`), never typing them.
  *
  *   SITE_GRAPH_DIR      'pub' — the site directory holding the fixed entries and, under
  *                       SITE_GRAPH_DIR/<build>/, the build-stamped module graph
  *   SITE_BUILD_ATTR     the <html> attribute of the IDE document carrying <build>
  *   SITE_BUILD_ID_RE    a <build>: the 8-hex-digit short sha of the commit the bundle was built from
+ *   siteBuildStampOf    the ONE reader of that stamp
  *   STATIC_APP_PAGE     the IDE bundle's entry document, beside the publisher's front page
  *   HOST_PROVIDED_ATTR  the attribute declaring a file host-provided (the publisher vendors it beside the page)
+ *   SITE_PLACEMENTS     each published package placed in the graph, and the graph directory it is placed at
+ *   SITE_ENTRY_PAGES, isSiteEntry
+ *                       the @descix/frqtl-web dist's HTML ENTRIES (reached by navigation or iframe, never loaded as a
+ *                       resource): the site keeps them at fixed URLs under SITE_GRAPH_DIR/, outside the stamped graph
+ *   siteGraphFaults     the served graph against the placed releases' dist-manifest.json records (empty = faithful)
  *   SITE_GRAPH_EXPORTS  the published names (the parity gate holds both packages' ./site-graph to this table)
  *
  * Host-neutral ESM with no imports: it loads unchanged in node and in a page.
  */
 
 /** The names `./site-graph` publishes. */
-export const SITE_GRAPH_EXPORTS = Object.freeze(['SITE_GRAPH_DIR', 'SITE_BUILD_ATTR', 'SITE_BUILD_ID_RE', 'STATIC_APP_PAGE', 'HOST_PROVIDED_ATTR']);
+export const SITE_GRAPH_EXPORTS = Object.freeze([
+    'SITE_GRAPH_DIR', 'SITE_BUILD_ATTR', 'SITE_BUILD_ID_RE', 'siteBuildStampOf', 'STATIC_APP_PAGE', 'HOST_PROVIDED_ATTR',
+    'SITE_PLACEMENTS', 'SITE_ENTRY_PAGES', 'isSiteEntry', 'siteGraphFaults',
+]);
 
 /** The static site's graph directory name (the entries sit in it, the graph under its build-stamped child). */
 export const SITE_GRAPH_DIR = 'pub';
@@ -30,6 +40,20 @@ export const SITE_BUILD_ATTR = 'data-frqtl-site-build';
 /** A build id: the 8-hex-digit short sha of the commit the bundle was built from. */
 export const SITE_BUILD_ID_RE = /^[0-9a-f]{8}$/;
 
+/**
+ * The build stamp an HTML document carries on <html SITE_BUILD_ATTR>, or null when absent.
+ * THROWS on more than one stamp. The ONE reader of the stamp.
+ * @param {string} html
+ * @returns {string|null}
+ */
+export function siteBuildStampOf(html) {
+    const stamps = [...html.matchAll(new RegExp('<html\\b[^>]*\\b' + SITE_BUILD_ATTR + '="([^"]*)"', 'gi'))].map((m) => m[1]);
+    if (stamps.length > 1) {
+        throw new Error('[site-graph] the document carries ' + stamps.length + ' ' + SITE_BUILD_ATTR + ' stamps: ' + stamps.join(', '));
+    }
+    return stamps.length ? stamps[0] : null;
+}
+
 /**
  * The static IDE bundle's entry document, beside its front page. The bundle ships THIS name and no
  * index.html: a site's index.html is the publisher's front page (lib/shim/host/host-view.js::HOST_FRONT_PAGE).
@@ -42,3 +66,119 @@ export const STATIC_APP_PAGE = 'app.html';
  * the bundle) and the publisher (the file must be PRESENT beside the page) read the set from this attribute.
  */
 export const HOST_PROVIDED_ATTR = 'data-frqtl-host-provided';
+
+/**
+ * Each published package the site places in its graph, and the graph-relative directory it is placed at ('' = the
+ * graph root). The router derives every same-origin URL into a package from its row; a publisher checks each
+ * placement against that package's installed `<package>/dist-manifest.json`.
+ */
+export const SITE_PLACEMENTS = Object.freeze([
+    Object.freeze({ package: '@descix/frqtl-web', dir: '' }),
+    Object.freeze({ package: '@descix/egpt-math-sdk', dir: 'egpt-math-sdk' }),
+]);
+
+/**
+ * The @descix/frqtl-web dist's HTML entry pages written by its entry writer (dist-root-relative). The experiment pages
+ * (experiments/{id}/index.html) are entries too; isSiteEntry names both.
+ */
+export const SITE_ENTRY_PAGES = Object.freeze(['sdk.html', 'artifact/sun.html', 'artifact/double-slit.html']);
+const EXPERIMENT_ENTRY = /^experiments\/[^/]+\/index\.html$/;
+
+/**
+ * Is this graph-relative path an entry page (which the site serves at SITE_GRAPH_DIR/<path>, never in the graph)?
+ * @param {string} rel
+ * @returns {boolean}
+ */
+export function isSiteEntry(rel) {
+    return SITE_ENTRY_PAGES.indexOf(rel) !== -1 || EXPERIMENT_ENTRY.test(rel);
+}
+
+/**
+ * Is a served site graph the placed releases' bytes? PURE: the caller enumerates and hashes.
+ *
+ * @param {{graph: Object<string,string>, entries: Set<string>}} served
+ *   graph    graph-relative path → sha256 hex, for EVERY file under SITE_GRAPH_DIR/<build>/
+ *   entries  the paths present under SITE_GRAPH_DIR/ outside the stamped directory (SITE_GRAPH_DIR-relative)
+ * @param {Array<{dir: string, name: string, version: string, files: Object<string,string>,
+ *                manifest: {file: string, sha256: string}}>} releases
+ *   one per SITE_PLACEMENTS row: its `dir`, the release's dist-manifest.json `name`, `version` and `files`, and the
+ *   manifest file itself (its dist-relative name and the sha256 of its bytes — the record no manifest lists).
+ * @returns {string[]} the faults, in a stable order (empty = the graph IS the releases):
+ *   - two placements at one dir, or a manifest key that falls under another placement's dir;
+ *   - a graph file with no owning placement (longest dir prefix), not listed by its owner, or of another sha256;
+ *   - a placement's manifest absent from the graph, or not the release's bytes;
+ *   - a listed file absent from the graph, unless it is an entry (isSiteEntry) present among `entries`;
+ *   - an entry still inside the graph (each entry has ONE URL).
+ */
+export function siteGraphFaults(served, releases) {
+    const graph = served && served.graph;
+    const entries = served && served.entries;
+    if (!graph || typeof graph !== 'object' || !(entries instanceof Set) || !Array.isArray(releases) || releases.length === 0) {
+        throw new Error('[site-graph] siteGraphFaults({graph: {path: sha256}, entries: Set}, releases[]) — got ' +
+            JSON.stringify({ graph: typeof graph, entries: Object.prototype.toString.call(entries), releases: Array.isArray(releases) ? releases.length : typeof releases }) + '.');
+    }
+    for (const r of releases) {
+        if (!r || typeof r.dir !== 'string' || !r.files || typeof r.files !== 'object' || !r.manifest ||
+            typeof r.manifest.file !== 'string' || typeof r.manifest.sha256 !== 'string') {
+            throw new Error('[site-graph] siteGraphFaults: each release is {dir, name, version, files, manifest: {file, sha256}} — got ' +
+                JSON.stringify(r && { dir: r.dir, name: r.name, version: r.version, manifest: r.manifest }) + '.');
+        }
+    }
+    const placed = (r, key) => (r.dir ? r.dir + '/' + key : key);
+    const label = (r) => r.name + '@' + r.version + (r.dir ? ' (at ' + r.dir + '/)' : ' (at the graph root)');
+    const ownerOf = (rel) => {
+        let best = null;
+        for (const r of releases) {
+            if ((r.dir === '' || rel.startsWith(r.dir + '/')) && (!best || r.dir.length > best.dir.length)) { best = r; }
+        }
+        return best;
+    };
+    const faults = [];
+
+    // 1. The placements are disjoint.
+    const dirs = releases.map((r) => r.dir);
+    for (const d of dirs) {
+        if (dirs.indexOf(d) !== dirs.lastIndexOf(d)) { faults.push('two placements at one dir: ' + JSON.stringify(d)); break; }
+    }
+    for (const r of releases) {
+        for (const key of Object.keys(r.files).sort()) {
+            const o = ownerOf(placed(r, key));
+            if (o !== r) { faults.push(label(r) + ' lists ' + key + ', which falls under ' + label(o) + ' — the placements overlap'); }
+        }
+    }
+
+    // 2. Every graph file is its owner's byte.
+    for (const rel of Object.keys(graph).sort()) {
+        const o = ownerOf(rel);
+        if (!o) { faults.push('graph file ' + rel + ' has no owning placement'); continue; }
+        const key = o.dir ? rel.slice(o.dir.length + 1) : rel;
+        if (key === o.manifest.file) {
+            if (graph[rel] !== o.manifest.sha256) {
+                faults.push('graph file ' + rel + ' is ' + graph[rel] + ', not ' + label(o) + '\'s integrity record (' + o.manifest.sha256 + ')');
+            }
+            continue;
+        }
+        if (!Object.prototype.hasOwnProperty.call(o.files, key)) {
+            faults.push('graph file ' + rel + ' is not listed by ' + label(o));
+        } else if (o.files[key] !== graph[rel]) {
+            faults.push('graph file ' + rel + ' is ' + graph[rel] + ', ' + label(o) + ' lists ' + o.files[key]);
+        }
+    }
+
+    // 3. Every listed file is served: in the graph, or (an entry) at its fixed URL and NOT in the graph.
+    for (const r of releases) {
+        const m = placed(r, r.manifest.file);
+        if (!Object.prototype.hasOwnProperty.call(graph, m)) { faults.push(label(r) + '\'s ' + r.manifest.file + ' is absent from the graph'); }
+        for (const key of Object.keys(r.files).sort()) {
+            const rel = placed(r, key);
+            const inGraph = Object.prototype.hasOwnProperty.call(graph, rel);
+            if (isSiteEntry(rel)) {
+                if (inGraph) { faults.push('entry ' + rel + ' (' + label(r) + ') is still inside the graph — an entry has one URL, at ' + SITE_GRAPH_DIR + '/' + rel); }
+                if (!entries.has(rel)) { faults.push('entry ' + rel + ' (' + label(r) + ') is absent from ' + SITE_GRAPH_DIR + '/'); }
+            } else if (!inGraph) {
+                faults.push(label(r) + ' lists ' + key + ' but it is absent from the graph');
+            }
+        }
+    }
+    return faults;
+}

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,7 +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                               record-format.js (THE owner of the Record folder's shape)
+ *   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.
@@ -24,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']);
+    '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 } from './record-format.js';
+    rowFaults, recordFolderFaults, applyRows } from './record-format.js';

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

@@ -0,0 +1,77 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * parts-spelling.js — THE rule for spelling a written value in a `parts` entry's OWN form. A hand's value and a Record
+ * row's value are the CAPTURE form (ObjectSchema.captureProps); the entry keeps the form its author wrote. Two
+ * consumers ask it, so the text and the block agree by construction:
+ *   - the writer (RecipeContext toSketch / setDeclared), reading the entry's form off the sketch TEXT;
+ *   - applyRows (record-format.js), reading it off a parts BLOCK ({ name: [kind name, props] }).
+ *
+ *   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). 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,
+ *       the reading placeDeclaredAt gives it); [x, y, z] stands. THROWS on anything else.
+ *
+ * `entryKeys()` → the keys the entry spells; `centerLength()` → the element count its `center` spells, or null.
+ * Both are asked lazily (only when a value needs them). Each function mutates and returns `props`.
+ */
+
+import { ObjectSchema } from '../../frqtl/objects/schema/index.js';
+
+const _JSON = function (v) { return JSON.stringify(v); };
+
+function _hasSix(props) {
+    return Object.keys(props).some(function (f) { return Array.isArray(props[f]) && props[f].length === 6; });
+}
+
+/** @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();
+    const baseline = o.baseline || {};
+    const R4 = ObjectSchema.RECT_TUPLE[4], R6 = ObjectSchema.RECT_TUPLE[6];
+    Object.keys(props).forEach(function (f) {
+        const v = props[f];
+        const rows = derived.filter(function (d) { return d.field === f && d.tuple === 6 && spelled.indexOf(d.name) !== -1; });
+        if (!rows.length || !Array.isArray(v) || v.length !== 6) { return; }
+        const b = Array.isArray(baseline[f]) && baseline[f].length === 6 ? baseline[f] : null;
+        const four = R4.map(function (k) { return v[R6.indexOf(k)]; });
+        if (b && _JSON(four) === _JSON(R4.map(function (k) { return b[R6.indexOf(k)]; }))) { delete props[f]; }
+        else { props[f] = four; }
+        rows.forEach(function (d) {
+            const nv = v[R6.indexOf(d.key)];
+            if (!b || nv !== b[R6.indexOf(d.key)]) { props[d.name] = nv; }
+        });
+    });
+    return props;
+}
+
+/** @param {number[]} v a spelled center @returns {number[]} its capture form [x, y, z] (a new array) */
+export function captureCenter(v) {
+    if (!Array.isArray(v) || (v.length !== 2 && v.length !== 3) || !v.every(function (n) { return typeof n === 'number'; })) {
+        throw new TypeError('[parts-spelling] captureCenter: a center is [x, y] or [x, y, z] numbers, got ' + JSON.stringify(v) + '. (FAIL-LOUD.)');
+    }
+    return v.length === 2 ? [v[0], v[1], 0] : v.slice();
+}
+
+/** @param {object} props @param {{ entryKeys: function(): string[], centerLength: function(): (number|null) }} o */
+export function spellCenter(props, o) {
+    const v = props.center;
+    if (!Array.isArray(v) || v.length !== 3 || v[2] !== 0) { return props; }
+    if (o.entryKeys().indexOf('center') === -1) { return props; }
+    if (o.centerLength() === 2) { props.center = [v[0], v[1]]; }
+    return props;
+}

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

@@ -22,9 +22,14 @@
  *   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)
+ *   applyRows(partsBlock, rows) → partsBlock   THE applier: a parts block with change rows applied in order (a new
+ *                        block; the input is never mutated)
  *
  * `files` is a tree { path → string | Uint8Array }: JSON and project text as strings (or UTF-8 bytes), clips
  * as bytes. Values in §6 files are strict JSON, in record.json's own vocabulary; a placeholder ("*",
@@ -33,6 +38,7 @@
 
 import { MANIFEST_FILE } from './manifest.js';
 import { entryOf } from './link.js';
+import { spellRect, spellCenter } from './parts-spelling.js';
 
 /** The folder's §6 paths. */
 export const RECORD_FILES = Object.freeze({
@@ -125,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);
@@ -225,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)); }
@@ -329,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);
@@ -343,3 +358,80 @@ export function serializeRecordFolder(p) {
     }
     return { files: files, record: record, clips: clips.map(function (c, i) { return { file: clipName(i + 1), firstTick: c.firstTick, lastTick: c.lastTick }; }) };
 }
+
+// ── the applier ─────────────────────────────────────────────────────────────────
+
+function _applyFail(i, msg) {
+    throw new Error('[record-format] applyRows: rows[' + i + '] ' + msg + '. (FAIL-LOUD.)');
+}
+
+/** The element count an entry's `center` value spells, or null. */
+function _centerLength(props) {
+    return Array.isArray(props.center) ? props.center.length : null;
+}
+
+/**
+ * applyRows(partsBlock, rows) → partsBlock — THE applier of §6 change rows to a parts block
+ * ({ "<name>": ["<registered kind name>", {props}] }, the parts.before.json / parts.after.json value), in order. Pure:
+ * returns a NEW block; neither argument is mutated. Per op (OPS):
+ *   move          entry `name` takes `to`'s one position key, spelled in the entry's own form
+ *   setDeclared   entry `name` takes each key of `to`, spelled in the entry's own form
+ *   add           `to` becomes entry `name`, as the LAST key
+ *   remove        entry `name` is dropped
+ *   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 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 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]>}
+ */
+export function applyRows(partsBlock, rows) {
+    const block = _partsValue(partsBlock, 'applyRows partsBlock');
+    if (!Array.isArray(rows)) {
+        throw new TypeError('[record-format] applyRows(partsBlock, rows): rows is the list of change rows (record.json changes), got ' +
+            JSON.stringify(rows) + '. (FAIL-LOUD.)');
+    }
+    rows.forEach(function (row, 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);
+        if (row.op === 'add') {
+            if (has) { _applyFail(i, 'adds "' + name + '", which the block already holds as ' + JSON.stringify(block[name])); }
+            block[name] = JSON.parse(JSON.stringify(row.to));
+            return;
+        }
+        if (!has) {
+            _applyFail(i, '(' + row.op + ') names the part "' + name + '", which the block does not hold (parts: ' +
+                Object.keys(block).join(', ') + ')');
+        }
+        const entry = block[name];
+        if (row.op === 'remove') { delete block[name]; return; }
+        if (row.op === 'fork') {
+            if (entry[0] !== row.from) {
+                _applyFail(i, 'forks "' + name + '" from the kind ' + JSON.stringify(row.from) + ', but the block declares it as ' + JSON.stringify(entry[0]));
+            }
+            block[name] = [row.to.kind, entry[1]];
+            return;
+        }
+        // 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];
+        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-p2.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-p2.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-p2.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": {