@descix/frqtl-node 0.6.0-p0.2 → 0.6.0-p1.1

package/dist/frqtl/objects/instruments/hosted-eyes.js

@@ -66,8 +66,8 @@
  *
  * A SceneRecord alone cannot open a host: it is identity plus reproduction pins, with no
  * scene spec in it. So the API takes the PAIR — record + `{kind:'project', files, entry}`, the
- * project whose entry's default export is `buildExperiment(exp)` (a one-string sketch, such as the
- * module `designToModule` emits, is `{ files: { 'sketch.js': text }, entry: 'sketch.js' }`). The
+ * project whose entry's default export is `buildExperiment(exp)` (a one-string sketch, such as a
+ * shipped scene file, is `{ files: { 'sketch.js': text }, entry: 'sketch.js' }`). The
  * page links it through its one door and stamps the project's identity (projectIdentity) as the
  * record's `sourceSha256`; this process computes the same identity from the same files, and the
  * open-time record check holds the two equal. A caller without one is REPLAY-grade
@@ -132,6 +132,7 @@ import { FrqtlCaptureHost } from './capture-host.js';
 import { FrqtlVision } from '../../parts/FrqtlVision.js';
 import { FrqtlCapture } from './capture.js';
 import { projectIdentity, projectBytes } from '../../../shim/project/identity.js';
+import { libPathOf } from '../../../shim/project/specifiers.js';
 
 
     /** The contracts this instrument consumes, by static import (it is a node-only module). */
@@ -145,22 +146,29 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
     }
 
     /**
-     * The URL, AS THE PAGE SEES IT, of a module beside this file. The canonical page sits at
-     * `frqtl/experiments/empty/index.html` of the same lib-identity tree in every host (source
-     * placement is identity), so a module's page URL is its path relative to that page's
-     * directory, resolved against the page's own URL. The in-page routines import the PAGE's
-     * module instances from these URLs — never a copy. @private
+     * The URL, AS THE PAGE SEES IT, of a module beside this file. MODULES sit at their
+     * lib-relative paths in lib/ and in every dist, so a module's lib path is its path from this
+     * tree's lib root. The PAGE does not: the dev mount serves it inside the lib tree, a dist
+     * re-anchors it (`<dist>/experiments/empty/`, the graph beside or under a build directory),
+     * so where the page sits says nothing about where its modules are. The page's own import map
+     * does — every row is its lib root plus a lib path (lib/shim/project/specifiers.js
+     * `importMapFor`, rendered for each placement) — so the lib root is asked of the page
+     * (`_IN_PAGE_LIB_ROOT` on `PAGE_ANCHOR`) and each module's lib path resolved against it.
+     * The in-page routines import the PAGE's module instances from these URLs — never a copy.
+     * @private
      */
-    var EMPTY_PAGE_DIR = path.dirname(fileURLToPath(new URL('../../experiments/empty/index.html', import.meta.url)));
-    function _pageModuleUrl(pageUrl, moduleUrl) {
-        var rel = path.relative(EMPTY_PAGE_DIR, fileURLToPath(moduleUrl)).split(path.sep).join('/');
-        return new URL(rel, pageUrl).href;
+    var LIB_ROOT_DIR = fileURLToPath(new URL('../../../', import.meta.url));
+    var PAGE_ANCHOR_SPECIFIER = '@descix/frqtl-web/parts';
+    var PAGE_ANCHOR = { specifier: PAGE_ANCHOR_SPECIFIER, libPath: libPathOf(PAGE_ANCHOR_SPECIFIER) };
+    function _pageModuleUrl(pageLibRoot, moduleUrl) {
+        var rel = path.relative(LIB_ROOT_DIR, fileURLToPath(moduleUrl)).split(path.sep).join('/');
+        return new URL(rel, pageLibRoot).href;
     }
-    /** The modules the capture-host KIND's in-page routines import, for the page at `pageUrl`. @private */
-    function _inPageModules(pageUrl) {
+    /** The modules the capture-host KIND's in-page routines import, for a page whose lib root is `pageLibRoot`. @private */
+    function _inPageModules(pageLibRoot) {
         return {
-            captureHost: _pageModuleUrl(pageUrl, import.meta.resolve('./capture-host.js')),
-            captureEnvelope: _pageModuleUrl(pageUrl, import.meta.resolve('../../../shim/render/capture-envelope.js'))
+            captureHost: _pageModuleUrl(pageLibRoot, import.meta.resolve('./capture-host.js')),
+            captureEnvelope: _pageModuleUrl(pageLibRoot, import.meta.resolve('../../../shim/render/capture-envelope.js'))
         };
     }
 
@@ -362,11 +370,11 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
     // ── The boot wait: every way it can fail is a NAMED refusal ─────────────────
 
     /**
-     * Where a published dist at `url`'s origin serves the one page. `url` is always
-     * `_pageUrlFor`'s absolute href, so its origin is known. @private
+     * Where a published dist serves the one page — under the dist's own URL, which may be an
+     * origin root or a sub-path, so it is named, not computed from `url`. @private
      */
-    function _distEmptyPage(url) {
-        return new URL(url).origin + '/experiments/empty/index.html';
+    function _distEmptyPage() {
+        return '<dist>/experiments/empty/index.html';
     }
 
     /** D — the URL did not serve (an HTTP status other than 2xx, or a navigation error). @private */
@@ -374,7 +382,7 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
         return new Error('[FrqtlHostedEyes.open] ' + url + ' did not serve: ' + what + '. That is ' +
             'a deployment fact, not a scene problem — the hosted eyes boot ONLY the canonical empty ' +
             'experiment page lib/frqtl/experiments/empty/index.html as your deployment serves it ' +
-            '(a published dist at this origin serves it at ' + _distEmptyPage(url) + '); point ' +
+            '(a published dist serves it at ' + _distEmptyPage() + ', <dist> being the URL the dist is served at); point ' +
             '`pageUrl` at it, or serve it. Nothing was booted. (FAIL-LOUD.)');
     }
 
@@ -383,7 +391,7 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
         return new Error('[FrqtlHostedEyes.open] ' + url + ' is not the canonical empty experiment ' +
             'page: it loaded (HTTP ' + status + ') and defines no window.FrqtlPage. The hosted eyes ' +
             'boot ONLY lib/frqtl/experiments/empty/index.html (in a published dist: ' +
-            _distEmptyPage(url) + ') and apply your scene into it. They never host an app page, the ' +
+            _distEmptyPage() + ') and apply your scene into it. They never host an app page, the ' +
             'IDE, or a page of your own: a page that boots and edits its own scene cannot be ' +
             'regenerated from {sceneRecord, sceneSource}. To see your own page, capture IN it ' +
             'through FrqtlVision (the in-page face). To drive it from node, use your own browser; ' +
@@ -558,6 +566,32 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
         return (td && td.universeData) ? td.universeData.tick : null;
     };
 
+    /**
+     * The page's lib root, resolved by the PAGE's import map: `anchor.specifier` resolves to the lib
+     * root plus `anchor.libPath`. A `blob:` module asks, because `import.meta.resolve` is the
+     * browser's own resolution against the document's map (the link site's blob modules resolve
+     * their imports the same way).
+     */
+    var _IN_PAGE_LIB_ROOT = async function (anchor) {
+        var url = URL.createObjectURL(new Blob(['export default import.meta.resolve(' +
+            JSON.stringify(anchor.specifier) + ');'], { type: 'text/javascript' }));
+        var resolved;
+        try { resolved = (await import(url)).default; }
+        catch (e) {
+            throw new Error('[FrqtlHostedEyes/in-page] this page\'s import map does not resolve ' +
+                JSON.stringify(anchor.specifier) + ' (' + ((e && e.message) || String(e)) + ') — the canonical ' +
+                'empty page carries the specifier table\'s import map; nothing can locate its modules ' +
+                'without it. (FAIL-LOUD.)');
+        }
+        finally { URL.revokeObjectURL(url); }
+        if (typeof resolved !== 'string' || resolved.slice(-anchor.libPath.length) !== anchor.libPath) {
+            throw new Error('[FrqtlHostedEyes/in-page] ' + JSON.stringify(anchor.specifier) + ' resolved to ' +
+                JSON.stringify(resolved) + ', which does not end in its lib path ' + JSON.stringify(anchor.libPath) +
+                ' — the page\'s import map is not the specifier table\'s rendering. (FAIL-LOUD.)');
+        }
+        return resolved.slice(0, resolved.length - anchor.libPath.length);
+    };
+
     /** Point the ONE camera and redraw — pose is a still coordinate, set before capture. */
     var _IN_PAGE_POSE = function (pose) {
         var r = window.FrqtlPage.runner;
@@ -595,7 +629,8 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
      *   `setPose` after open overrides its camera. Omit it for a scene's PLAIN render.
      * @param {string} opts.pageUrl — the canonical empty experiment page in YOUR deployment
      *   (dev server: `<origin>/frqtl/experiments/empty/index.html`; published dist:
-     *   `<origin>/experiments/empty/index.html`). Required rather than guessed: the address of
+     *   `<dist>/experiments/empty/index.html`, where `<dist>` is the dist's URL — an origin root
+     *   or a sub-path). Required rather than guessed: the address of
      *   a deployment is not something a library may invent.
      * @param {object} opts.browserType — a Playwright browser type (`chromium`). The
      *   `@descix/frqtl-node/eyes` entry supplies the packaged default; passing your own IS the
@@ -626,7 +661,7 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
             throw new Error('[FrqtlHostedEyes.open] `pageUrl` is REQUIRED: the URL of the ' +
                 'CANONICAL empty experiment page (lib/frqtl/experiments/empty/index.html) in your ' +
                 'deployment — a dev server exposes it at its /frqtl mount, a published dist at ' +
-                '<origin>/experiments/empty/index.html. A library may not invent the address of ' +
+                '<dist>/experiments/empty/index.html (<dist> = the URL the dist is served at). A library may not invent the address of ' +
                 'your deployment, and it must not ship a second copy of that page. (FAIL-LOUD.)');
         }
         if (!opts.browserType || typeof opts.browserType.launch !== 'function') {
@@ -641,7 +676,7 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
         var sourceRef = (record.sourceRef === undefined || record.sourceRef === null)
             ? null : String(record.sourceRef);
 
-        var browser = null, page = null;
+        var browser = null, page = null, modules = null;
         return Promise.resolve(opts.browserType.launch({
             headless: true,
             args: Array.isArray(opts.launchArgs) ? opts.launchArgs : _defaultLaunchArgs()
@@ -735,6 +770,11 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
                 _assertLanded(boot.renderState);
             });
         }).then(function () {
+            // Asked of the FINAL page (after any display reload), once: the in-page routines import
+            // its module instances from these URLs.
+            return page.evaluate(_IN_PAGE_LIB_ROOT, PAGE_ANCHOR);
+        }).then(function (pageLibRoot) {
+            modules = _inPageModules(pageLibRoot);
             return page.evaluate(_IN_PAGE_SCENE);
         }).then(function (pageScene) {
             // The caller's `build`/`projection`, if any, were an EXPECTATION about what the
@@ -760,7 +800,7 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
                             'is closed. Open a new one; a capture surface that silently ' +
                             'resurrected a browser would leak processes by design. (FAIL-LOUD.)');
                     }
-                    return page.evaluate(C.CH.IN_PAGE_CAPTURE, { stage: stage, modules: _inPageModules(page.url()) })
+                    return page.evaluate(C.CH.IN_PAGE_CAPTURE, { stage: stage, modules: modules })
                         .then(function (env) { return C.CH.decodeStillEnvelope(env); });
                 },
                 record: function (recordOpts) {
@@ -775,14 +815,14 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
                     var signal = recordOpts.signal || null;
                     var pageOpts = {};
                     for (var k in recordOpts) { if (k !== 'signal') { pageOpts[k] = recordOpts[k]; } }
-                    var begun = page.evaluate(C.CH.IN_PAGE_RECORD_BEGIN, { id: id, opts: pageOpts, modules: _inPageModules(page.url()) });
+                    var begun = page.evaluate(C.CH.IN_PAGE_RECORD_BEGIN, { id: id, opts: pageOpts, modules: modules });
                     gate.opened = begun.then(null, function () {});
                     var onAbort = null;
                     var aborted = null;
                     if (signal) {
                         var sendAbort = function () {
                             return begun.then(function () {
-                                return page.evaluate(C.CH.IN_PAGE_RECORD_ABORT, { id: id, modules: _inPageModules(page.url()) });
+                                return page.evaluate(C.CH.IN_PAGE_RECORD_ABORT, { id: id, modules: modules });
                             });
                         };
                         if (signal.aborted) { aborted = sendAbort(); }
@@ -793,7 +833,7 @@ import { projectIdentity, projectBytes } from '../../../shim/project/identity.js
                     }
                     var detach = function () { if (onAbort) { signal.removeEventListener('abort', onAbort); } };
                     return begun.then(function () {
-                        return page.evaluate(C.CH.IN_PAGE_RECORD_END, { id: id, modules: _inPageModules(page.url()) });
+                        return page.evaluate(C.CH.IN_PAGE_RECORD_END, { id: id, modules: modules });
                     }).then(function (env) {
                         detach();
                         // A failed ABORT delivery is surfaced, never swallowed.

package/dist/frqtl/objects/objects/QuantumEmitter.js

@@ -597,7 +597,7 @@ import { declaredCount } from '../ObjectFactory.js';
                 type: 'rect',
                 engineVisible: true,
                 description: 'Canonical bounding rect ' + ValueNormalizer.rectTupleText(4) + ' — repositions the single emission ' +
-                    'source rect. WS Studio Controls Realignment S4: routed through ' +
+                    'source rect. Routed through ' +
                     'QuantumEmitter.setSourceRect() (mutates emState.sourceRects directly — the ' +
                     'RETIRED provider ABI updateEmitterSourceRects no longer exists post-G-EMIT-2). ' +
  'The emitter moves its own marker.'

package/dist/frqtl/objects/schema/index.js

@@ -42,6 +42,7 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
 import * as FrameDataSchema from '../../../shim/frame-data/index.js';
 import * as FieldDescriptorSchema from '../../../shim/field-descriptor/index.js';
 import * as ValueNormalizer from './valueNormalizer.js';
+import * as LoDrawnCenter from '../../compat/renderer/lo-drawn-center.js';
 import { SCOPE_DESCRIPTORS, shapeValuesMap } from './scopes.js';
 import { kindOf, registeredKinds, placeableKinds } from '../kinds.js';
 
@@ -135,6 +136,18 @@ import { kindOf, registeredKinds, placeableKinds } from '../kinds.js';
         }
     }
 
+    /** A deep copy of arrays and plain objects; any other value (a primitive, a class instance) as it is. */
+    function _plainCopy(v) {
+        if (v === null || typeof v !== 'object') { return v; }
+        if (Array.isArray(v)) { return v.map(_plainCopy); }
+        if (ArrayBuffer.isView(v)) { return Array.from(v); }
+        var proto = Object.getPrototypeOf(v);
+        if (proto !== Object.prototype && proto !== null) { return v; }
+        var out = {};
+        Object.keys(v).forEach(function (k) { out[k] = _plainCopy(v[k]); });
+        return out;
+    }
+
     var ObjectSchema = {
         /**
          * get(name) → the descriptor: a kind a module registered in THIS realm (objects/kinds.js),
@@ -212,6 +225,65 @@ import { kindOf, registeredKinds, placeableKinds } from '../kinds.js';
          * @param {string} kind
          * @returns {object}
          */
+        /**
+         * captureProps(obj, kind) → the plain props bag of a live object, read through its kind's descriptor:
+         * every declared field whose value is defined, deep-copied (arrays and plain objects; any other object
+         * is left as the value it is, so a writer refuses it by name); a `rect` field read as a {left, top, w, h}
+         * shape is captured in its write form: RECT_TUPLE[6] when it carries a z-extent (LoDrawnCenter.hasZ),
+         * else RECT_TUPLE[4]. A `writeOnly` field (a live reposition
+         * adapter — SphereEmitter.rect, Tunnel.rect) is skipped: the part's real position fields are captured.
+         * THROWS for a kind with no descriptor: there is no descriptor-less walk.
+         * Consumers: RecipeContext (the parts writer's baseline and its diff), the IDE's inspector reads.
+         * @param {object} obj — a live declared object
+         * @param {string} kind — its kind (runner.kindOf(obj))
+         * @returns {object}
+         */
+        captureProps: function (obj, kind) {
+            var descriptor = _descriptor(kind);
+            if (!descriptor || !Array.isArray(descriptor.fields)) {
+                throw new Error('[ObjectSchema] captureProps(obj, "' + kind + '"): no descriptor for kind "' + kind +
+                    '" in this realm — a capture reads the kind\'s declared fields, never the object\'s own keys. (FAIL-LOUD.)');
+            }
+            var props = {};
+            for (var i = 0; i < descriptor.fields.length; i++) {
+                var field = descriptor.fields[i];
+                if (field.writeOnly === true) { continue; }
+                var val = obj[field.name];
+                if (val === undefined) { continue; }
+                // A `rect` field READS as a {left, top, w, h} shape (a Rectangle) but is WRITTEN as the
+                // tuple whose order valueNormalizer.js::RECT_TUPLE owns: the capture is the write form.
+                // A rect with a z-extent (LoDrawnCenter.hasZ) is captured in the 6-number form, a flat one in the
+                // 4-number form, so a baseline and a live capture agree on form and a z move is a `rect` diff.
+                if (field.type === 'rect' && val && typeof val === 'object' && !Array.isArray(val)) {
+                    var form = LoDrawnCenter.hasZ(val) ? 6 : 4;
+                    var tuple = ValueNormalizer.RECT_TUPLE[form].map(function (k) {
+                        return k === 'd' ? LoDrawnCenter.zExtent(val) : val[k];
+                    });
+                    if (tuple.every(function (n) { return typeof n === 'number'; })) {
+                        props[field.name] = tuple;
+                        continue;
+                    }
+                }
+                props[field.name] = _plainCopy(val);
+            }
+            return props;
+        },
+        /**
+         * derivedReads(kind) → [{ name, field, tuple, key }] — the kind's readonly reads that a write field owns
+         * (a descriptor row's `derivedFrom`: e.g. Wall `z` = RECT_TUPLE[6] key 'z' of `rect`). Data only: the
+         * write authority stays the named field. THROWS for a kind with no descriptor.
+         * @param {string} kind
+         * @returns {{name: string, field: string, tuple: number, key: string}[]}
+         */
+        derivedReads: function (kind) {
+            var descriptor = _descriptor(kind);
+            if (!descriptor || !Array.isArray(descriptor.fields)) {
+                throw new Error('[ObjectSchema] derivedReads("' + kind + '"): no descriptor for kind "' + kind + '". (FAIL-LOUD.)');
+            }
+            return descriptor.fields.filter(function (f) { return !!f.derivedFrom; }).map(function (f) {
+                return { name: f.name, field: f.derivedFrom.field, tuple: f.derivedFrom.tuple, key: f.derivedFrom.key };
+            });
+        },
         defaultPropsFor: function (kind) {
             var row = kindOf(kind);
             return (row && row.defaults) ? row.defaults : {};

package/dist/frqtl/parts/DetectorWall.js

@@ -283,7 +283,7 @@ import { registerKind } from '../objects/kinds.js';
         if (tickData != null && tickData === this._lastTickData) {
             throw new Error(
                 '[DetectorWall] getCollisionHistogram() called twice with the SAME TickData ' +
-                'object — each tick must be consumed exactly once (fraqtl#61 double-count guard). ' +
+                'object — each tick must be consumed exactly once, or its collisions are counted twice. ' +
                 'Call universe.doTick() again before re-consuming.'
             );
         }

package/dist/frqtl/parts/FrqtlControlsPanel.js

@@ -173,8 +173,10 @@ function _dispatchControlsCall(registry, fn, args) {
                 hit.kind + '", not "action". (FAIL-LOUD.)');
         }
         var ctxA = registry._controlBindCtx || {};
-        _ControlActionNode.resolveAction(hit.action, { runner: ctxA.runner }).run();
-        return { action: hit.action };
+        // `done` settles when the action has (a restart replays asynchronously: runner.restart() is a
+        // Promise for every scene); a failed replay REJECTS it, so a host that awaits it sees the error.
+        var ran = _ControlActionNode.resolveAction(hit.action, { runner: ctxA.runner }).run();
+        return { action: hit.action, done: Promise.resolve(ran) };
     }
     if (fn === 'setControlValue') {
         var name2 = args[0], id = args[1], value = args[2];

package/dist/frqtl/parts/Wall.js

@@ -969,6 +969,7 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
             {
                 name: 'depth',
                 type: 'readonly',
+                derivedFrom: { field: 'rect', tuple: 6, key: 'd' },
                 unit: 'px',
                 engineVisible: false,
                 description: 'The wall\'s z-slab depth (z-extent) in physics pixels — 0 for a flat 2D ' +
@@ -978,6 +979,7 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
             {
                 name: 'z',
                 type: 'readonly',
+                derivedFrom: { field: 'rect', tuple: 6, key: 'z' },
                 unit: 'px',
                 engineVisible: false,
                 description: 'The wall\'s z placement (near-face … far-face CENTER) in physics pixels ' +

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

@@ -5,29 +5,33 @@
  *
  * 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 (`exp.addObject`) and the render intent are all here; the sugar
+ * 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 } from '@descix/frqtl-web/parts';
+import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // 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.
-  var W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-  var cy = Math.round(H / 2);
-  var SRC = {
+// 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
-  };
-  exp.createScene(W, H, 600, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
-  exp.addObject('SphereEmitter', SRC);
-  exp.addObject('Wall', {
+  }],
+  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,
-    name: 'absorber', color: [150, 90, 210]
-  });
+    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

@@ -5,28 +5,32 @@
  *
  * 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 (`exp.addObject`) and the render intent are all here; the sugar
+ * 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 } from '@descix/frqtl-web/parts';
+import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // 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.
-  var W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-  var cy = Math.round(H / 2);
-  var SRC = {
+// 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
-  };
-  exp.createCanvas(W, H, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.addObject('SphereEmitter', SRC);
-  exp.addObject('Wall', {
+  }],
+  absorber: [Wall, {
     rect: [Math.round(W * 0.6), Math.round(H * 0.2), 20, Math.round(H * 0.6)],
     collisionBehavior: 'absorb', capacity: 64,
-    name: 'absorber', color: [150, 90, 210]
-  });
+    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

@@ -24,6 +24,8 @@ 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)
 
@@ -34,6 +36,7 @@ export default function buildExperiment(exp) {
 
   // ── 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);

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

@@ -18,6 +18,8 @@
 
 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)
 
@@ -29,6 +31,7 @@ export default function buildExperiment(exp) {
   // 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 ──────

package/dist/frqtl/scenes/blackbody.js

@@ -21,18 +21,27 @@
  * the oven, the thermostat, the sink. Same calls, same order, same seed ⇒ the same RNG stream.
  */
 
-import { CollisionActions, CollisionTypes, FrqtlControlOverlay, FrqtlControlsPanel, Rectangle } from '@descix/frqtl-web/parts';
+import { CollisionActions, CollisionTypes, FrqtlControlOverlay, FrqtlControlsPanel, LargeObject, Rectangle } from '@descix/frqtl-web/parts';
 import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
 
-export default function buildExperiment(exp) {
-  var W = 600, H = 400;        // THE WORLD this scene states (its co-init call below)
+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)
-  var SINK_DEPTH = 30;         // the absorbing strip at the right canvas edge (px)
 
   // ── WORLD — a 2D canvas + universe, fundamental layer 0 (1x1 leaves), λ multiplier 1 ──
   exp.createCanvas(W, H, { dimension: 0, wavelengthScale: 1 });
@@ -57,13 +66,7 @@ export default function buildExperiment(exp) {
   });
   u.experimentTickFunctions[thermostatSlot] = oven.getTemperatureTickFunction();
 
-  // ── THE SINK — the experiment boundary on the slit side ─────────────────
-  exp.addObject('LargeObject', {
-    name: 'radiation_sink',
-    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]
-  });
+  exp.declare(parts);   // the sink (parts.radiation_sink)
 
   // ── THE KNOB — temperature, live (the oven's own thermostat target) ─────
   var registry = ControlRegistry.makeControlRegistry();

package/dist/frqtl/scenes/circuit-sat.js

@@ -22,6 +22,8 @@
 import { FrqtlControlOverlay, FrqtlControlsPanel, LogicGate, SphereEmitter, Trace } from '@descix/frqtl-web/parts';
 import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
 
+export const parts = {};
+
 export default function buildExperiment(exp) {
   var W = 760, H = 520;              // THE WORLD this scene states (its co-init call below)
   var LEFT = 60, TOP = 15;           // the circuit's top-left
@@ -40,6 +42,7 @@ export default function buildExperiment(exp) {
 
   // ── WORLD — a 2D canvas + universe; the emitter's own world (its worldCfg) ──
   exp.createCanvas(W, H, SphereEmitter.worldCfg(emitterBag(null)));
+  exp.declare(parts);
   var u = exp.universe;
 
   var MIN = LogicGate.MINIMAL;                                  // bore 3 / wall 3 / length 20
@@ -57,7 +60,7 @@ export default function buildExperiment(exp) {
     { input: 'A', gate: 'SUM', port: 'inPortA' }, { input: 'B', gate: 'SUM', port: 'inPortB' },
     { input: 'B', gate: 'CARRY', port: 'inPortA' }, { input: 'A', gate: 'CARRY', port: 'inPortB' }
   ];
-  var rails = { A: [], B: [] }, parts = [];
+  var rails = { A: [], B: [] }, traces = [];
   LANES.forEach(function (row, i) {
     var port = gates[row.gate][row.port], y = port[1];
     var t = new Trace(u, { path: [[port[0] - LEAD, y], [port[0], y]], bore: MIN.bore,
@@ -66,7 +69,7 @@ export default function buildExperiment(exp) {
                                                           { name: 'input' + row.input + i }));   // parked inside the bore mouth
     em.setActive(row.input === 'A' ? STATE.a : STATE.b);
     rails[row.input].push(em);
-    parts.push(t);
+    traces.push(t);
   });
 
   // ── THE READOUTS — grounded traces off each gate's outlet: their current IS the answer ──
@@ -75,8 +78,8 @@ export default function buildExperiment(exp) {
                           bore: MIN.bore, wallThickness: MIN.wallThickness, ground: true, name: name, color: [60, 160, 220] });
   }
   var readouts = { SUM: readout(sum, 'SUM_out'), CARRY: readout(carry, 'CARRY_out') };
-  parts.push(readouts.SUM, readouts.CARRY);
-  parts.forEach(function (p) { p.attachToRunner(exp.runner); });   // every trace reads the tick stream (a declared gate subscribed at addObject)
+  traces.push(readouts.SUM, readouts.CARRY);
+  traces.forEach(function (p) { p.attachToRunner(exp.runner); });   // every trace reads the tick stream (a declared gate subscribed at addObject)
 
   function setInput(which, on) {
     STATE[which] = !!on;

package/dist/frqtl/scenes/collision-matrix-3d.js

@@ -22,12 +22,15 @@ import { CameraControls, FrqtlControlOverlay, FrqtlControlsPanel } from '@descix
 import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
 import { collisionMatrixLanes } from '@descix/frqtl-web/objects/setup/_collisionMatrixLanes.js';
 
+export const parts = {};
+
 export default function buildExperiment(exp) {
   var W = 700, H = 700, D = 700;    // THE WORLD this scene states (its co-init call below)
   var LEVEL = 6;                    // the voxel layer: 64 px bodies, capacity 4096
 
   // ── WORLD — a 3D scene + universe W×H×D, fundamental layer 0, λ multiplier 1 ──
   exp.createScene(W, H, D, { dimension: 0, wavelengthScale: 1 });
+  exp.declare(parts);
   var u = exp.universe;
   u.withInterQuantumCollisions = true;
   u.addDimension(LEVEL);