@descix/frqtl-node 0.6.1-p3.3 → 0.7.0-p0

package/dist/shim/registry/scene-source.js

@@ -1,141 +1,116 @@
 /* Copyright 2023-2026 by Essam Abadir */
 
 /**
- * scene-source.js — the ONE reader of a registry scene as a PROJECT, in a page AND in node.
+ * scene-source.js — the ONE reader of a scene as a PROJECT, in a page AND in node.
  *
- * A scene is ONE sketch file, `lib/frqtl/scenes/<file>.js`: a module whose default export is
- * `buildExperiment(exp)`, holding the whole scene (world, parts, render intent). A registry row carries
- * its frqtl-relative PATH (`source: 'scenes/<file>.js'`), never its text. Every consumer that needs the
- * scene (the GYM's rung frame, STUDIO, the hero, a package consumer of `@descix/frqtl-web/registry`) asks
- * here, so the id → path → URL → project chain exists once.
+ * A scene is ONE sketch file: a module whose default export is `buildExperiment(exp)`, holding the whole scene
+ * (world, parts, render intent). A host's roster names each scene's file relative to the roster
+ * (roster.js::sceneUrlOf); the Empty Universe is the package's own sketch
+ * (lib/frqtl/experiments/_shared/empty-sketch.js), read through the router like any package file.
  *
- *   scenePath(rung)                         → 'scenes/<file>.js'   (THROWS on any other shape)
- *   projectOf(scene, { router?, fetch?, mode? })
- *                                           → Promise<{ manifest, files, renderState }>
- *       files       { 'frqtl.json': serializeManifest(manifestFor({ name: row.id, entry: 'sketch.js' })),
+ *   projectOf(roster, id, { fetch?, mode? })  → Promise<{ manifest, files, renderState }>
+ *       files       { 'frqtl.json': serializeManifest(manifestFor({ name: id, entry: 'sketch.js' })),
  *                     'sketch.js': <the scene file's text> } — the folder a host boots
- *                     (bootProject(mount, { files, mint }, { renderState }), no entry needed)
  *       manifest    that frqtl.json's normalized bag
- *       renderState effectiveRenderState(row, mode) — the registry's one derivation, ferried BESIDE the folder
- *                   (boot facts never enter frqtl.json or the project identity)
+ *       renderState effectiveRenderState(row, mode) — boot facts ride BESIDE the folder, never in frqtl.json
+ *   emptyProjectOf({ router, fetch? })        → the same shape for the Empty Universe (name EMPTY_PROJECT_NAME,
+ *                                               renderState normalizeSavedRenderState({}))
+ *   EMPTY_PROJECT_NAME                        'empty'
+ *   EMPTY_SKETCH_PATH                         the Empty Universe's router path (a package builder places that file
+ *                                             in every dist this module ships in: sdk/_build/hosts.mjs)
  *
- * `scene` is a rung id (resolved by `walkthroughById`; an unknown id REJECTS naming the declared ids) or a
- * row (`{id, source}`, e.g. `EMPTY_SCENE`). The URL comes from a router, the one path authority
- * (lib/shim/engine/router.js, `scenes/` profile key):
- *   - `opts.router` — the host's own (the IDE's engineRouter); a host always passes it.
- *   - absent — the PACKAGE's: the dist layout anchored at the dist root this module ships in
- *     (`PACKAGE_ROOT_FROM_HERE`, dist/shim/registry/ → dist/). This is the `@descix/frqtl-web/registry`
- *     door's reader; in the source tree it names a file that is not there and rejects.
- * The read is lib/shim/project/read-text.js readText (a capability split on the resolved URL: a `file:` URL
- * through node's fs, anything else fetched).
+ * The read is lib/shim/project/read-text.js readText (a `file:` URL through node's fs, anything else fetched).
  *
- * FAIL-LOUD: an unknown id, a row without a scenes/ path, an undeclared mode, a non-200 response, an
- * unreadable file or an empty body REJECTS naming the scene and the URL. A blank scene is never a result.
+ * FAIL-LOUD: a non-bag roster, an undeclared id or mode, an unknown option, a non-200, an unreadable file or an
+ * empty body REJECTS naming the scene and the URL. A blank scene is never a result.
  *
  * Zero physics: this moves text. The scene's physics is whatever its file composes.
  */
 
 'use strict';
 
-import { WALKTHROUGH, walkthroughById, effectiveRenderState } from './walkthrough.js';
-import { engineRouter } from '../engine/router.js';
+import { assertRosterBag, walkthroughById, effectiveRenderState, sceneUrlOf } from './roster.js';
+import { normalizeSavedRenderState } from '../render-state/index.js';
 import { MANIFEST_FILE, manifestFor, serializeManifest } from '../project/manifest.js';
 import { SKETCH_ENTRY } from '../project/link.js';
 import { readText } from '../project/read-text.js';
 
-/** The one path prefix a scene file lives under (the router's `scenes/` profile key). */
-export var SCENES_PREFIX = 'scenes/';
+/** The project name of the Empty Universe (its frqtl.json `name`). */
+export const EMPTY_PROJECT_NAME = 'empty';
 
-/**
- * Where the package's dist root sits relative to this module once shipped: build.js places
- * lib/shim/ at dist/shim/ (sdk/_build/lib-dist-placement.cjs), so this file is
- * dist/shim/registry/scene-source.js. verify-publish-surface reads every rung through it on the
- * built dist, so a moved placement fails there.
- */
-var PACKAGE_ROOT_FROM_HERE = '../../';
-
-/**
- * The blank world — STUDIO's "Empty Universe" — is itself a scene file (the empty page states no
- * world of its own). A row-shaped handle so it reads through the same `projectOf`.
- */
-export var EMPTY_SCENE = Object.freeze({ id: 'empty', source: 'scenes/empty.js' });
+/** The Empty Universe's sketch, a lib-identity path every router profile resolves. */
+export const EMPTY_SKETCH_PATH = 'experiments/_shared/empty-sketch.js';
 
-var OPT_KEYS = ['router', 'fetch', 'mode'];
+const PROJECT_OF = 'projectOf(roster, id, { fetch, mode })';
+const EMPTY_PROJECT_OF = 'emptyProjectOf({ router, fetch })';
 
-/**
- * @param {{id?:string, source?:string}} rung — a registry row.
- * @returns {string} the frqtl-relative scene path.
- */
-export function scenePath(rung) {
-    var src = rung && rung.source;
-    if (typeof src !== 'string' || src.indexOf(SCENES_PREFIX) !== 0 || !/\.js$/.test(src)) {
-        throw new Error('[scene-source] rung "' + (rung && rung.id) + '" declares source ' +
-            JSON.stringify(src) + ' — a scene row carries the path of its sketch file, ' +
-            "'scenes/<file>.js' (lib/frqtl/scenes/). (FAIL-LOUD.)");
+function assertOpts(opts, allowed, signature) {
+    const o = opts === undefined ? {} : opts;
+    if (o === null || typeof o !== 'object' || Array.isArray(o)) {
+        throw new Error('[scene-source] ' + signature + ': options are an object (got ' + JSON.stringify(opts) + '). (FAIL-LOUD.)');
     }
-    return src;
+    Object.keys(o).forEach((k) => {
+        if (allowed.indexOf(k) === -1) {
+            throw new Error('[scene-source] ' + signature + ' has no option "' + k + '" — options: ' + allowed.join(', ') +
+                (k === 'router' ? '; a roster scene\'s URL is sceneUrlOf(roster, row), not a router path' : '') + '. (FAIL-LOUD.)');
+        }
+    });
+    return o;
 }
 
-function _rowOf(scene) {
-    if (typeof scene === 'string') {
-        var rung = walkthroughById(scene);
-        if (!rung) {
-            throw new Error('[scene-source] unknown rung id "' + scene + '" — declared ids: [' +
-                WALKTHROUGH.map(function (r) { return r.id; }).join(', ') + ']. (FAIL-LOUD.)');
+function folderOf(name, url, label, opts, renderState) {
+    return readText(url, { fetch: opts.fetch }).catch((e) => {
+        throw new Error('[scene-source] ' + label + ' — ' + ((e && e.message) || e) + '. (FAIL-LOUD.)');
+    }).then((t) => {
+        if (typeof t !== 'string' || !t.trim()) {
+            throw new Error('[scene-source] ' + label + ' — ' + url + ' has an empty body. (FAIL-LOUD.)');
         }
-        return rung;
-    }
-    if (!scene || typeof scene !== 'object') {
-        throw new Error('[scene-source] projectOf takes a rung id or a registry row, got ' +
-            JSON.stringify(scene) + '. (FAIL-LOUD.)');
-    }
-    return scene;
+        const manifest = manifestFor({ name, entry: SKETCH_ENTRY });
+        const files = {};
+        files[MANIFEST_FILE] = serializeManifest(manifest);
+        files[SKETCH_ENTRY] = t;
+        return { manifest, files, renderState };
+    });
 }
 
-function _packageRouter() {
-    var root = new URL(PACKAGE_ROOT_FROM_HERE, import.meta.url).href.replace(/\/$/, '');
-    return engineRouter({ mode: 'cdn', base: root });
+/**
+ * A roster scene as the project folder a host boots, with its renderState beside it.
+ * @param {object} roster  a normalized roster bag (roster.js normalizeRoster / roster-link.js loadRoster)
+ * @param {string} id      a scene id the roster declares
+ * @param {{fetch?: function, mode?: string|null}} [opts]  fetch: injectable for a non-file URL; mode: a declared
+ *   mode of the scene (absent: its default) for the renderState
+ * @returns {Promise<{manifest: object, files: Object<string,string>, renderState: object}>}
+ */
+export function projectOf(roster, id, opts) {
+    return Promise.resolve().then(() => {
+        assertRosterBag(roster, PROJECT_OF);
+        const o = assertOpts(opts, ['fetch', 'mode'], PROJECT_OF);
+        if (typeof id !== 'string' || id === '') {
+            throw new Error('[scene-source] ' + PROJECT_OF + ' takes a scene id string (got ' + JSON.stringify(id) + '). (FAIL-LOUD.)');
+        }
+        const row = walkthroughById(roster, id);
+        if (!row) {
+            throw new Error('[scene-source] ' + PROJECT_OF + ': "' + id + '" is not a declared scene — declared: [' +
+                roster.rows.map((r) => r.id).join(', ') + ']. (FAIL-LOUD.)');
+        }
+        const renderState = effectiveRenderState(row, o.mode);   // an undeclared mode rejects before the read
+        return folderOf(row.id, sceneUrlOf(roster, row), 'scene "' + row.id + '"', o, renderState);
+    });
 }
 
 /**
- * A registry scene as the project folder a host boots, with the host's boot bag beside it.
- * @param {string|{id:string, source:string}} scene — a rung id, or a registry row.
- * @param {{router?:{resolve:function(string):string}, fetch?:function, mode?:string|null}} [opts]
- *   router — the host's engineRouter (absent: the package's own dist root);
- *   fetch  — the fetch used for a non-file URL (defaults to the global; injectable for tests);
- *   mode   — a declared walk-through mode (absent: the rung's default) for the renderState.
+ * The Empty Universe as a project folder: the package sketch read through the host's router.
+ * @param {{router: {resolve: function(string): string}, fetch?: function}} opts
  * @returns {Promise<{manifest: object, files: Object<string,string>, renderState: object}>}
  */
-export function projectOf(scene, opts) {
-    return Promise.resolve().then(function () {
-        opts = opts || {};
-        Object.keys(opts).forEach(function (k) {
-            if (OPT_KEYS.indexOf(k) === -1) {
-                throw new Error('[scene-source] projectOf has no option "' + k + '" — options: ' +
-                    OPT_KEYS.join(', ') + '. (FAIL-LOUD.)');
-            }
-        });
-        var row = _rowOf(scene);
-        var rel = scenePath(row);
-        var renderState = effectiveRenderState(row, opts.mode);   // an undeclared mode rejects before the read
-        var router = opts.router || _packageRouter();
-        if (typeof router.resolve !== 'function') {
-            throw new Error('[scene-source] opts.router has no resolve() — pass an engineRouter ' +
-                '(lib/shim/engine/router.js) to resolve ' + rel + '. (FAIL-LOUD.)');
+export function emptyProjectOf(opts) {
+    return Promise.resolve().then(() => {
+        const o = assertOpts(opts, ['router', 'fetch'], EMPTY_PROJECT_OF);
+        if (!o.router || typeof o.router.resolve !== 'function') {
+            throw new Error('[scene-source] ' + EMPTY_PROJECT_OF + ' needs the host\'s engineRouter ' +
+                '(lib/shim/engine/router.js) to resolve ' + EMPTY_SKETCH_PATH + '. (FAIL-LOUD.)');
         }
-        var url = router.resolve(rel);
-        return readText(url, { fetch: opts.fetch }).catch(function (e) {
-            throw new Error('[scene-source] scene "' + row.id + '" — ' + ((e && e.message) || e) + '. (FAIL-LOUD.)');
-        }).then(function (t) {
-            if (typeof t !== 'string' || !t.trim()) {
-                throw new Error('[scene-source] scene "' + row.id + '" — ' + url +
-                    ' has an empty body. (FAIL-LOUD.)');
-            }
-            var manifest = manifestFor({ name: row.id, entry: SKETCH_ENTRY });
-            var files = {};
-            files[MANIFEST_FILE] = serializeManifest(manifest);
-            files[SKETCH_ENTRY] = t;
-            return { manifest: manifest, files: files, renderState: renderState };
-        });
+        const url = o.router.resolve(EMPTY_SKETCH_PATH);
+        return folderOf(EMPTY_PROJECT_NAME, url, 'the Empty Universe', o, normalizeSavedRenderState({}));
     });
 }

package/dist/shim/registry/studio-landing.js

@@ -4,7 +4,7 @@
  * studio-landing.js — the ONE record of how STUDIO resolved the deep link it opened with, as host-view.js records
  * its view outcome: STUDIO's resolver (lib/features/ide/studio-landing-of.js::studioLandingOf) decides the row and
  * AuthorView.jsx writes it on `document.documentElement` under STUDIO_LANDING_ATTR, through recordStudioLanding,
- * and a gate that opens a link (a showcase tile, showcase-link.js) reads that attribute instead of STUDIO's DOM or
+ * and a gate that opens a link (a showcase tile, roster.js showcaseHref) reads that attribute instead of STUDIO's DOM or
  * its error copy.
  *
  *   STUDIO_LANDING_ATTR          the <html> attribute carrying the outcome id
@@ -33,23 +33,31 @@ 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', 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' },
+      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 scene opens' },
     { id: 'conflict', runs: false,
-      means: 'the link names both a walkthrough and a saved project: nothing opens' },
+      means: 'the link names more than one scene source (two of walkthrough, project and scene), or a renderer beside a walkthrough or a project, which carry their own: nothing opens' },
     { id: 'mode-without-walkthrough', runs: false,
       means: 'the link names a mode and no walkthrough: nothing opens' },
+    { id: 'renderer-without-scene', runs: false,
+      means: 'the link names a renderer and no scene; a renderer is chosen only for a scene link: nothing opens' },
     { id: 'unknown-walkthrough', runs: false,
-      means: 'the linked walkthrough is not in the walkthrough registry (walkthroughById): nothing opens' },
+      means: 'the linked walkthrough is not a scene of the loaded roster (walkthroughById(roster, id)): nothing opens' },
     { id: 'unknown-mode', runs: false,
-      means: 'the linked mode is not one the linked rung declares (walkthroughModes): nothing opens' },
+      means: 'the linked mode is not one the linked scene declares (walkthroughModes): nothing opens' },
+    { id: 'scene-refused-origin', runs: false,
+      means: 'the linked scene URL is on neither the page\'s origin nor the roster\'s (roster-link.js sceneOriginRefusalOf): the strip names the rule and both origins; nothing opens' },
+    { id: 'scene-unreadable', runs: false,
+      means: 'the linked scene URL is allowed but its read failed (a non-200, an empty body, or not a .js sketch): nothing opens' },
     { 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', runs: false,
       means: 'no saved project of the linked name in this browser: nothing opens' },
     { 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' },
+      means: 'the linked walkthrough (in the linked mode, else its default), saved project or scene 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' },
+      means: 'no STUDIO deep link: the roster\'s first-contact scene (firstContactOf(roster)) opens' },
+    { id: 'first-contact-empty', runs: false,
+      means: 'no STUDIO deep link and the roster declares no first contact: the Empty Universe opens' },
 ].map(Object.freeze));
 
 const IDS = new Set(STUDIO_LANDING_OUTCOMES.map((r) => r.id));

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

@@ -13,8 +13,7 @@
  * `godrayMode` 'radial' is the sun's own (its rays fan from one light point, the source frames' centroid).
  * The camera is NOT here: a pose is a rung row's view, not a look.
  *
- * Readers: `lib/shim/registry/walkthrough.js` (a named import); a scene sketch may import it too
- * (`@descix/frqtl-web/shim/render/sun-look.js`). Zero physics: render
+ * Readers: a scene sketch, by its package specifier (`@descix/frqtl-web/shim/render/sun-look.js`). Zero physics: render
  * options are read only by the renderer.
  */
 

package/llms.txt

@@ -1,13 +1,15 @@
 # @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.3 on npm dist-tag `next`. Node ≥ 22.12.
+> `bootNode` and the hosted eyes. 0.7.0-p0 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.
 - `./eyes`: `openHostedEyes({ sceneRecord, sceneSource: { kind: 'project', files, entry }, pageUrl })`.
 - `./project`: `linkProject` links a scene file against this package's own copy.
+- `./registry`: the roster contract: `loadRoster(<file: URL of a host's roster>)` → the bag every reader takes first (`projectOf(roster, id, { mode })`, `effectiveRenderState(row, mode)`, `showcaseHref(roster, card)`, …); the package ships no scene rows.
+- See it run: https://egpt-frqtl.descix.net
 - `./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.3/CLAUDE.md
+- Full agent guide: https://cdn.jsdelivr.net/npm/@descix/frqtl-node@0.7.0-p0/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.3",
+  "version": "0.7.0-p0",
   "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": {

package/dist/frqtl/scenes/absorbing-wall-3d.js

@@ -1,37 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — 1B · Absorbing Wall (3D)
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world
- * (its co-init call, `exp.createCanvas` / `exp.createScene` — the one place its size is written),
- * the parts (`export const parts` + `exp.declare`, or `exp.addObject`) and the render intent are all here; the sugar
- * objects, renderer and engine are imports. Registered by lib/shim/registry/walkthrough.js
- * (rung cl1b-absorbing-wall-3d).
- */
-
-import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
-
-// Collision Lab 1B · 3D — a volumetric (spherical) source into a 3D ABSORB wall
-// slab (z-slab centered on 0 so the 3D spray collides); orbit the camera to view.
-const W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-const cy = Math.round(H / 2);
-
-export const parts = {
-  source: [SphereEmitter, {
-    preset: 'spherical', is2D: false, center: [Math.round(W * 0.15), cy],
-    chargeMode: 'random', fundamentalDimension: 2, wavelength: 32,
-    burstSize: 24, emitEveryTicks: 1
-  }],
-  absorber: [Wall, {
-    rect: [Math.round(W * 0.6), Math.round(H * 0.2), 20, Math.round(H * 0.6)],
-    z: -80, depth: 160,
-    collisionBehavior: 'absorb', capacity: 64,
-    color: [150, 90, 210]
-  }],
-};
-
-export default function buildExperiment(exp) {
-  exp.createScene(W, H, 600, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
-  exp.declare(parts);
-}

package/dist/frqtl/scenes/absorbing-wall.js

@@ -1,36 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — 1B · Absorbing Wall
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world
- * (its co-init call, `exp.createCanvas` / `exp.createScene` — the one place its size is written),
- * the parts (`export const parts` + `exp.declare`, or `exp.addObject`) and the render intent are all here; the sugar
- * objects, renderer and engine are imports. Registered by lib/shim/registry/walkthrough.js
- * (rung cl1b-absorbing-wall).
- */
-
-import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
-
-// Collision Lab 1B (Absorbing Wall) — ABSORB v2 (Track A): the wall LO is backed by
-// a REAL leaf frame; a host tick-fn tallies the killed masses into it + radiates.
-const W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-const cy = Math.round(H / 2);
-
-export const parts = {
-  source: [SphereEmitter, {
-    preset: 'spherical', is2D: true, center: [Math.round(W * 0.15), cy],
-    chargeMode: 'random', fundamentalDimension: 2, wavelength: 32,
-    burstSize: 24, emitEveryTicks: 1
-  }],
-  absorber: [Wall, {
-    rect: [Math.round(W * 0.6), Math.round(H * 0.2), 20, Math.round(H * 0.6)],
-    collisionBehavior: 'absorb', capacity: 64,
-    color: [150, 90, 210]
-  }],
-};
-
-export default function buildExperiment(exp) {
-  exp.createCanvas(W, H, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.declare(parts);
-}

package/dist/frqtl/scenes/atomic-model.js

@@ -1,91 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — Atomic model
- *
- * A sketch file: the WHOLE scene as one `export default function buildExperiment(exp)` module. The
- * world and the three-level frame hierarchy are built here from the engine's own primitives (leaf
- * frames — `engine().Frame`, read when the scene builds — and parent frames from a rect). Registered by
- * lib/shim/registry/walkthrough.js (rung atomic-model).
- *
- * Physics (zero new — bench H1, A1, A2, M1, M4): 48 one-pixel quarks fill an 8x8 proton frame; the
- * proton and one electron sit in a 64x64 atom frame. There is no force equation. Each parent's
- * compress() pulls its children one pixel toward its centre each tick (A1: a stationary parent
- * CONFINES a child), a parent's motion is carried by its children (A2), a parent's mass is its
- * child count (H1), and its wavelength is capacity/mass (M4) — 64/48 → the proton's oscillation.
- * The atom is stationary: the lab frame. `bonding` (noEscape) traps each quark in its parent's
- * live rect, so the nucleus holds together: binding emerges from compress, not from a law.
- *
- * Order (it seeds the run): world → the three layers → quarks (grid-filled, registered) → proton
- * from its rect → electron (registered) → atom from its rect → electron into the atom.
- */
-
-import { Rectangle } from '@descix/frqtl-web/parts';
-import * as OrbitBag from '@descix/frqtl-web/compat/renderer/orbit-bag.js';
-import { engine } from '@descix/frqtl-web/compat/engine.js';
-
-export const parts = {};
-
-export default function buildExperiment(exp) {
-  var W = 600, H = 600;          // THE WORLD this scene states (its co-init call below)
-
-  var QUARK_LAYER = 0;        // 1x1 leaves
-  var SUBATOMIC_LAYER = 3;    // the proton: 8x8, capacity 64
-  var ATOM_LAYER = 6;         // the atom: 64x64, capacity 4096
-  var QUARKS_PER_PROTON = 48; // the proton's mass at t=0 → wavelength 64/48
-
-  // ── WORLD — a 2D canvas + universe: quark layer fundamental, λ multiplier 1, quarks confined ──
-  exp.createCanvas(W, H, { dimension: QUARK_LAYER, wavelengthScale: 1, bonding: true });
-  exp.declare(parts);
-  var u = exp.universe;
-
-  var quarkDim = u.addDimension(QUARK_LAYER);
-  var subatomicDim = u.addDimension(SUBATOMIC_LAYER);
-  var atomDim = u.addDimension(ATOM_LAYER);
-  var subatomicW = subatomicDim.mb_w, atomW = atomDim.mb_w;
-
-  var Frame = engine().Frame, Charge = engine().Charge;   // the engine's own frame primitive + charge ABI
-  var cx = Math.round(W / 2), cy = Math.round(H / 2);
-  var atomRect = new Rectangle(cx, cy, atomW, atomW, null, true);
-  var protonRect = new Rectangle(cx, cy, subatomicW, subatomicW, null, true);
-  var rect = exp.runner.canvas_rect;
-
-  // ── QUARKS — fill the proton rect column by column ─────────────────────
-  var quarkW = Math.max(1, Math.pow(2, QUARK_LAYER));
-  var quarks = [];
-  for (var x = protonRect.left; x < protonRect.left + protonRect.w && quarks.length < QUARKS_PER_PROTON; x += quarkW) {
-    for (var y = protonRect.top; y < protonRect.top + protonRect.h && quarks.length < QUARKS_PER_PROTON; y += quarkW) {
-      var q = Frame.makeLeafFrame(x, y, QUARK_LAYER, 1, 0, 0, false, Charge.POSITIVE, rect);
-      q.name = 'quark_' + quarks.length;
-      quarks.push(q);
-    }
-  }
-  for (var i = 0; i < quarks.length; i++) { quarkDim.addFrame(quarks[i]); }
-
-  // ── PROTON — the parent frame of the quarks ────────────────────────────
-  var proton = subatomicDim.createFrameFromRect(protonRect, quarks, 0, 0);
-  proton.name = 'proton';
-
-  // ── ELECTRON — one negative leaf, upper-right of the atom ──────────────
-  var electron = Frame.makeLeafFrame(atomRect.left + Math.round(atomW * 0.75), atomRect.top + Math.round(atomW * 0.25),
-                                     QUARK_LAYER, 1, 0, 0, false, Charge.NEGATIVE, rect);
-  electron.name = 'electron';
-  quarkDim.addFrame(electron);
-
-  // ── ATOM — stationary parent of the proton; the electron joins directly ─
-  var atom = atomDim.createFrameFromRect(atomRect, [proton], 0, 0, true, true);
-  atom.name = 'atom';
-  atom.insert(electron);
-
-  u.leafQuantaWidth = quarkW;
-  u.brownianMotion = true;
-
-  // ── VIEW — frame the atom (render only: the 2D camera's `distance` is the visible physics-px
-  //    height). The atom is 64 px in the world; at 1.5x its width it fills two thirds of the view,
-  //    so the proton, its quarks and the electron are individually legible. ─────────────────────
-  var cam = exp.runner.cameraControl;
-  var flat = !OrbitBag.hasAngularPose(cam);
-  if (cam && typeof cam.setOrbit === 'function' && flat) {
-    cam.setOrbit({ target: { x: cx, y: cy }, distance: Math.round(atomW * 1.5) });
-  }
-}

package/dist/frqtl/scenes/big-bang.js

@@ -1,49 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — Big Bang
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world and the
- * point source are built here; the sugar (PointSource — deprecated V1 sugar, byte-identical), the
- * renderer and the engine are imports. Registered by lib/shim/registry/walkthrough.js (rung big-bang).
- *
- * Physics (zero new — bench M1, H1, H2a-c): one radial burst at the canvas centre — 72 rays (5°) at
- * radii 32 → 2 — of leaves with NO initial momentum (emergentPhysics). The world generates parent
- * frames top-down (by how many frames an area can parent, brownian on), so a uniform field clumps into
- * filaments and voids with no gravity law and no cosmological constant. The source shuts off after
- * 20 s of ticks (1200).
- *
- * Order (it seeds the run): world (with its parent-generation interval) → source → the shut-off tick-fn.
- */
-
-import { PointSource } from '@descix/frqtl-web/parts';
-
-export const parts = {};
-
-export default function buildExperiment(exp) {
-  var W = 600, H = 600;          // THE WORLD this scene states (its co-init call below)
-
-  var SOURCE_DIAMETER = 64;     // emission radii 32 → 2 (step 2)
-  var ANGLE_STEP = 5;           // degrees between rays → 72 rays
-  var EMIT_TICKS = 20 * 60;     // the source fires for 1200 ticks
-
-  // ── WORLD — a 2D canvas + universe: fundamental layer 0, λ multiplier 1, parents top-down ──
-  // iframeIntervalSeconds 1/60: parents are generated EVERY tick (the engine freezes the interval at
-  // init, so it rides the world cfg — at the default 1 s, Phase B ran every 60 ticks).
-  exp.createCanvas(W, H, { dimension: 0, wavelengthScale: 1, frames: true, iframeIntervalSeconds: 1 / 60 });
-  exp.declare(parts);
-  var u = exp.universe;
-
-  // ── THE SOURCE — at the centre, no initial momentum, random charge ──────
-  var source = new PointSource(u, Math.floor(W / 2), Math.floor(H / 2), SOURCE_DIAMETER,
-                               0, null, true, Infinity, 0, ANGLE_STEP,
-                               { emergentPhysics: true, minRadius: 2 });
-
-  // ── SHUT-OFF — the bang is one burst era, then the field evolves on its own ──
-  var t = 0;
-  exp.addTickFunction(function () {
-    t++;
-    if (t >= EMIT_TICKS) { source.setActive(false); }
-    return [];
-  });
-}

package/dist/frqtl/scenes/blackbody.js

@@ -1,84 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — Blackbody
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world, the
- * oven, its thermostat and the radiation sink are all constructed here; the sugar objects
- * (OvenBox, LargeObject), the renderer and the engine are imports. Registered by
- * lib/shim/registry/walkthrough.js (rung blackbody).
- *
- * Physics (zero new — composition of goldened behaviours): a cavity of absorbing walls holds a
- * population of leaves; the OvenBox thermostat keeps the cavity's quanta near the TEMPERATURE
- * target by emitting, and colliding leaves merge into parent frames (bench H2a–c,
- * collide → merge → promote; `withInterQuantumCollisions`). A parent's fullness IS its frequency
- * (wavelength = capacity/mass, bench M4), so what leaks out of the slit in the right wall is a
- * spectrum of frame sizes — the emergent Planck-like curve — with no energy quanta assumed.
- * Everything that escapes is absorbed by the sink at the right edge (the experiment boundary).
- *
- * Order matters (it seeds the run): the world, the brownian/collision flags, the quantum
- * layer, the thermostat SLOT (reserved before the oven so the oven's own tick-fns run after it),
- * the oven, the thermostat, the sink. Same calls, same order, same seed ⇒ the same RNG stream.
- */
-
-import { CollisionActions, CollisionTypes, FrqtlControlOverlay, FrqtlControlsPanel, LargeObject, Rectangle } from '@descix/frqtl-web/parts';
-import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
-
-const W = 600, H = 400;        // THE WORLD this scene states (its co-init call below)
-const SINK_DEPTH = 30;         // the absorbing strip at the right canvas edge (px)
-
-export const parts = {
-  // ── THE SINK — the experiment boundary on the slit side ─────────────────
-  radiation_sink: [LargeObject, {
-    rect: { left: W - SINK_DEPTH, top: 0, w: SINK_DEPTH, h: H },
-    collision_type: CollisionTypes.NONE, actions: [CollisionActions.ABSORB],
-    reposition: 'closest', color: [0, 0, 0]
-  }],
-};
-
-export default function buildExperiment(exp) {
-  var TEMPERATURE = 1500;      // target quanta inside the cavity (the knob below)
-  var QUANTUM_DIM = 3;         // the layer leaves promote into: an 8 px box edge, 64 cells of capacity in 2D
-  var BOX_FRACTION = 1 / 3;    // the cavity's outer box, as a fraction of the canvas
-  var WALL = 10;               // wall thickness (px)
-  var SLIT_HEIGHT = 60;        // the radiation slit in the right wall (px)
-
-  // ── WORLD — a 2D canvas + universe, fundamental layer 0 (1x1 leaves), λ multiplier 1 ──
-  exp.createCanvas(W, H, { dimension: 0, wavelengthScale: 1 });
-  var u = exp.universe;
-  u.brownianMotion = true;
-  u.withInterQuantumCollisions = true;
-  u.addDimension(QUANTUM_DIM);
-
-  // ── THE OVEN — the cavity, centred on the canvas ────────────────────────
-  var outer = new Rectangle(Math.round(W / 2), Math.round(H / 2),
-                            Math.round(W * BOX_FRACTION), Math.round(H * BOX_FRACTION), null, true);
-  // The thermostat runs FIRST each tick: reserve its slot before the oven registers its own.
-  var thermostatSlot = u.experimentTickFunctions.length;
-  u.experimentTickFunctions.push(null);
-  var oven = exp.addObject('OvenBox', {
-    name: 'oven',
-    left: outer.left + WALL, top: outer.top + WALL,
-    width: outer.w - 2 * WALL, height: outer.h - 2 * WALL,
-    wallThickness: WALL, temperature: TEMPERATURE,
-    slitHeight: SLIT_HEIGHT,          // the slit is in the RIGHT wall (OvenBox's own slit side)
-    color: [120, 120, 120]
-  });
-  u.experimentTickFunctions[thermostatSlot] = oven.getTemperatureTickFunction();
-
-  exp.declare(parts);   // the sink (parts.radiation_sink)
-
-  // ── THE KNOB — temperature, live (the oven's own thermostat target) ─────
-  var registry = ControlRegistry.makeControlRegistry();
-  registry.registerControls('blackbody', [
-    { kind: 'scalar', id: 'temperature', label: 'temperature (quanta)', min: 50, max: 8000, step: 50,
-      value: TEMPERATURE, fmt: function (v) { return String(v); },
-      onChange: function (v) { oven.setTemperature(v); },
-      place: { x: 0.02, y: 0.03 } }
-  ]);
-  // Chrome (a page only): expose the knobs to a host frame, and mount the overlay through the
-  // runner's ONE door (runner.controlHost) — before a canvas is mounted (a notebook pane) there is
-  // none, so the knobs stay in the exposed registry only.
-  FrqtlControlsPanel.exposeRegistry(registry, { runner: exp.runner });
-  if (exp.runner.controlHost) { FrqtlControlOverlay.mount(exp.runner, { registry: registry, name: 'blackbody' }); }
-}