@descix/frqtl-node 0.6.0-p4.1 → 0.6.0

package/dist/frqtl/parts/Wall.js

@@ -178,10 +178,20 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
     }
 
     function _rectFromOpts(opts) {
-        // Normalize an OBJECT-bag rect ({left,top,w,h} / {left,top,z,w,h,d} — the shape a
-        // codegen round-trip captures from the live LO, restart-bug fix 2026-07-25) to the
-        // canonical ARRAY form FIRST, so the 3D checks below (_rectIs3D/_rectDepth are
-        // Array-based) see a captured 3D wall as 3D. Mirrors LargeObject's own rectToArray.
+        // ONE spelling of the z-slab: a rect that already carries z/depth (the 6-element form, or an
+        // object rect with z/d) beside the z / d / depth props would be two statements of one fact,
+        // one of them silently ignored. Refused, naming both.
+        var slabProps = ['z', 'd', 'depth'].filter(function (k) { return opts[k] !== undefined; });
+        if (slabProps.length && opts.rect && (Array.isArray(opts.rect) ? opts.rect.length === 6
+                : (opts.rect.z !== undefined || opts.rect.d !== undefined))) {
+            throw new Error('[Wall] rect is already the z/depth form ' + ValueNormalizer.rectTupleText(6) +
+                ' and the props also give ' + slabProps.join(', ') + ' — write the z-slab ONE way: the 6-element rect, ' +
+                'or a 4-element rect beside z/depth. (FAIL-LOUD.)');
+        }
+        // Normalize an OBJECT-bag rect ({left,top,w,h} / {left,top,z,w,h,d} — the shape a live LO's
+        // rect reads as) to the canonical ARRAY form FIRST, so the 3D checks below
+        // (_rectIs3D/_rectDepth are Array-based) see such a 3D wall as 3D. Mirrors LargeObject's
+        // own rectToArray.
         if (opts.rect && !Array.isArray(opts.rect) && opts.rect.left !== undefined && opts.rect.w !== undefined) {
             var ob = opts.rect;
             var arr = (ob.z !== undefined || ob.d !== undefined)
@@ -382,7 +392,7 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
             self._radiationTickFn = tickFn;
             // The radiator OWNS the live emissivity (including the default when none was
             // stated). Read the facade prop back off it rather than leaving it undefined —
-            // captureProps/codegen and the Inspector read `wall.emissivity`, and a facade that
+            // captureProps (the parts writer) and the Inspector read `wall.emissivity`, and a facade that
             // says nothing while the radiator says 0.5 is a second, wrong answer.
             self.emissivity = tickFn.emissivity();
             if (universe && Array.isArray(universe.experimentTickFunctions)) {
@@ -399,10 +409,10 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
     function Wall(universe, opts) {
         opts = opts || {};
         this.universe = universe;
-        this._schemaKind = 'Wall';
+        this._schemaKind = this.constructor.name;
 
-        // A `preset` expands to the v2 descriptor fields (construction sugar; codegen
-        // round-trips the EXPANDED fields, never the preset name).
+        // A `preset` expands to the v2 descriptor fields (construction sugar; the parts
+        // writer captures the EXPANDED fields, never the preset name).
         if (opts.preset) {
             var expanded = expandWallPreset(opts.preset);
             var merged = {}; Object.keys(opts).forEach(function (k) { if (k !== 'preset') { merged[k] = opts[k]; } });
@@ -437,7 +447,7 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
     // ── Descriptor-field read surface (captureProps / Inspector) ─────────────
     // captureProps(wall, WallDescriptor) reads wall[field.name] directly; these
     // getters expose the LIVE inner-LO state so a dragged/edited wall Saves at its
-    // current state (the codegen round-trip authority). `rect` is the single
+    // current state (what the parts writer captures). `rect` is the single
     // captured position authority (the LO's own Rectangle, whose toJSON pins the
     // {left,top,w,h} wire shape).
     Object.defineProperty(Wall.prototype, 'rect',        { get: function () { return this.lo ? this.lo.rect : undefined; } });
@@ -573,7 +583,7 @@ import { wallBehaviorV2ValuesMap as _wallBehaviorV2ValuesMap, bounceDirectionVal
      */
     Wall.prototype.setV2Prop = function (prop, value) {
         // EMISSIVITY — live radiating efficiency. The running radiator OWNS the value (one
-        // live copy); the facade prop is a ferried mirror for the Inspector/codegen read.
+        // live copy); the facade prop is a ferried mirror for the Inspector and capture read.
         // Validation (fullness fraction in (0,1]) belongs to the owner and throws from there.
         if (prop === 'emissivity') {
             if (this.collisionBehavior !== 'absorb' || !this._radiationTickFn) {

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

@@ -22,6 +22,7 @@
 import { FrqtlControlOverlay, FrqtlControlsPanel, LogicGate, SphereEmitter, Trace } from '@descix/frqtl-web/parts';
 import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
 
+// Code-declared on purpose: the emitter centres and rail traces derive from the gates' port geometry and RAIL (a knob rewrites it), and a Trace has no kind — a literal block would restate derived geometry by hand.
 export const parts = {};
 
 export default function buildExperiment(exp) {

package/dist/frqtl/scenes/dse-one-emitter.js

@@ -67,9 +67,10 @@
 // 2D ONLY, deliberately. There is no `modes` strip and no `exp.is3D` guard: these
 // rungs declare one world each. A second dimensional variant would be a separate
 // recipe declaration, not a mode.
-// THE PAIR. `dse-two-emitters.js` is the SAME apparatus with NSRC = 2. The two files differ ONLY in
-// the title lines and the `var NSRC` line — lib/frqtl/scenes/test/scene-files.test.mjs
-// fails if any other line diverges, so the A/B the pair exists to make stays an A/B.
+// THE PAIR. `dse-two-emitters.js` is the SAME apparatus with TWO source entries. The two files differ ONLY in the
+// title lines, this note, and their `source*` entries of `parts` (with the world call naming the first
+// of them) — lib/frqtl/scenes/test/scene-files.test.mjs fails if anything else diverges, so the A/B the
+// pair exists to make stays an A/B.
 
 import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 
@@ -116,7 +117,34 @@ const detW = Math.round(lamPx / 64);      // 5   — plate thickness
 // the photoelectric experiment, and it saturates.
 const detectorPreset = 'transparent-probe';
 
+const lamArg = 3.2;                       // capacity/mass -> fullness 1/3.2 = 0.3125 (yellow)
+const fwl    = 4 * (lamPx / lamArg);      // 400 -> wavelengthScale floor(400/4) = 100
+const wlScale = Math.floor(fwl / 4);      // 100
+const cy   = Math.round(H / 2);           // 200 — the source plane's midline
+// TWO-SOURCE SEPARATION. Two sources reinforce when their separation is a
+// multiple of lambda/2, and the coupling falls as (lambda/d)^2, so lambda/2 is
+// the strongest case. At this leg it also puts a band of EACH source on the
+// midline y = H/2 (source 1's lower band and source 2's upper band coincide
+// there) — the doubly-reinforced central peak, equidistant from both emitters,
+// exactly where the one-source rung has no peak at all.
+const sep  = lamPx / 2;                   // 160 -> sources at y 120 and 280
+// ── THE LIGHT SOURCE ────────────────────────────────────────────────────
+// preset 'hemisphere' = 180 degrees of FORWARD (+X) emission: the SAME
+// ball-rejected sampler as the omni source with the forward axis' range halved,
+// so nothing about the walk changes, it is simply pointed at the plate. The
+// default emission box is 0 for this preset, so the source is a single PIXEL —
+// load-bearing, because any spread at birth blurs every band by that spread.
+// NO START WALL: the backward population is empty by construction, and `wrap` is
+// false, so the canvas edge kills whatever transverse wiggle out-runs its
+// forward component. One sink, not two.
+const SRC = {
+  preset: 'hemisphere', is2D: true, chargeMode: 'random',
+  wavelength: lamArg, fundamentalDimension: 2, fundamentalWaveLength: fwl,
+  burstSize: 8, emitEveryTicks: 1
+};
+
 export const parts = {
+  source: [SphereEmitter, { ...SRC, center: [srcX, cy] }],
   // FAR-EDGE SINK. The plate below counts WITHOUT removing, so quanta fly on past
   // it; this is the experiment-boundary sink downstream of the plate. It is not
   // load-bearing (wrap is false, so the canvas edge would remove them anyway) — it
@@ -134,41 +162,11 @@ export const parts = {
 };
 
 export default function buildExperiment(exp) {
-  var NSRC = 1;
-  var lamArg = 3.2;                       // capacity/mass -> fullness 1/3.2 = 0.3125 (yellow)
-  var fwl    = 4 * (lamPx / lamArg);      // 400 -> wavelengthScale floor(400/4) = 100
-  var wlScale = Math.floor(fwl / 4);      // 100
   if (Math.abs(lamArg * wlScale - lamPx) > 1e-9) {
     throw new Error('[dse-h1] lamPx ' + lamPx + ' is not realisable as lambda_eff: the engine ' +
       'can only produce wavelengthArg x floor(fwl/4) = ' + (lamArg * wlScale) + '. (FAIL-LOUD.)');
   }
-  var cy   = Math.round(H / 2);           // 200 — the source plane's midline
-  // TWO-SOURCE SEPARATION. Two sources reinforce when their separation is a
-  // multiple of lambda/2, and the coupling falls as (lambda/d)^2, so lambda/2 is
-  // the strongest case. At this leg it also puts a band of EACH source on the
-  // midline y = H/2 (source 1's lower band and source 2's upper band coincide
-  // there) — the doubly-reinforced central peak, equidistant from both emitters,
-  // exactly where the one-source rung has no peak at all.
-  var sep  = lamPx / 2;                   // 160 -> sources at y 120 and 280
-  var srcYs = (NSRC === 2) ? [cy - sep / 2, cy + sep / 2] : [cy];
-  // ── THE LIGHT SOURCE ────────────────────────────────────────────────────
-  // preset 'hemisphere' = 180 degrees of FORWARD (+X) emission: the SAME
-  // ball-rejected sampler as the omni source with the forward axis' range halved,
-  // so nothing about the walk changes, it is simply pointed at the plate. The
-  // default emission box is 0 for this preset, so the source is a single PIXEL —
-  // load-bearing, because any spread at birth blurs every band by that spread.
-  // NO START WALL: the backward population is empty by construction, and `wrap` is
-  // false, so the canvas edge kills whatever transverse wiggle out-runs its
-  // forward component. One sink, not two.
-  var SRC = {
-    preset: 'hemisphere', is2D: true, chargeMode: 'random',
-    wavelength: lamArg, fundamentalDimension: 2, fundamentalWaveLength: fwl,
-    burstSize: 8, emitEveryTicks: 1
-  };
-  exp.createCanvas(CW, H, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  for (var si = 0; si < srcYs.length; si++) {
-    exp.addObject('SphereEmitter', Object.assign({}, SRC, { center: [srcX, Math.round(srcYs[si])] }));
-  }
+  exp.createCanvas(CW, H, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
   const p = exp.declare(parts);
   // ── THE INSTRUMENT — the live count-by-y histogram, REGISTERED TO THE PLATE ──
   // The panel takes the plate's OWN rect y-origin (0) and height (H), so the two

package/dist/frqtl/scenes/dse-two-emitters.js

@@ -67,9 +67,10 @@
 // 2D ONLY, deliberately. There is no `modes` strip and no `exp.is3D` guard: these
 // rungs declare one world each. A second dimensional variant would be a separate
 // recipe declaration, not a mode.
-// THE PAIR. `dse-one-emitter.js` is the SAME apparatus with NSRC = 1. The two files differ ONLY in
-// the title lines and the `var NSRC` line — lib/frqtl/scenes/test/scene-files.test.mjs
-// fails if any other line diverges, so the A/B the pair exists to make stays an A/B.
+// THE PAIR. `dse-one-emitter.js` is the SAME apparatus with ONE source entry. The two files differ ONLY in the
+// title lines, this note, and their `source*` entries of `parts` (with the world call naming the first
+// of them) — lib/frqtl/scenes/test/scene-files.test.mjs fails if anything else diverges, so the A/B the
+// pair exists to make stays an A/B.
 
 import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 
@@ -116,7 +117,35 @@ const detW = Math.round(lamPx / 64);      // 5   — plate thickness
 // the photoelectric experiment, and it saturates.
 const detectorPreset = 'transparent-probe';
 
+const lamArg = 3.2;                       // capacity/mass -> fullness 1/3.2 = 0.3125 (yellow)
+const fwl    = 4 * (lamPx / lamArg);      // 400 -> wavelengthScale floor(400/4) = 100
+const wlScale = Math.floor(fwl / 4);      // 100
+const cy   = Math.round(H / 2);           // 200 — the source plane's midline
+// TWO-SOURCE SEPARATION. Two sources reinforce when their separation is a
+// multiple of lambda/2, and the coupling falls as (lambda/d)^2, so lambda/2 is
+// the strongest case. At this leg it also puts a band of EACH source on the
+// midline y = H/2 (source 1's lower band and source 2's upper band coincide
+// there) — the doubly-reinforced central peak, equidistant from both emitters,
+// exactly where the one-source rung has no peak at all.
+const sep  = lamPx / 2;                   // 160 -> sources at y 120 and 280
+// ── THE LIGHT SOURCE ────────────────────────────────────────────────────
+// preset 'hemisphere' = 180 degrees of FORWARD (+X) emission: the SAME
+// ball-rejected sampler as the omni source with the forward axis' range halved,
+// so nothing about the walk changes, it is simply pointed at the plate. The
+// default emission box is 0 for this preset, so the source is a single PIXEL —
+// load-bearing, because any spread at birth blurs every band by that spread.
+// NO START WALL: the backward population is empty by construction, and `wrap` is
+// false, so the canvas edge kills whatever transverse wiggle out-runs its
+// forward component. One sink, not two.
+const SRC = {
+  preset: 'hemisphere', is2D: true, chargeMode: 'random',
+  wavelength: lamArg, fundamentalDimension: 2, fundamentalWaveLength: fwl,
+  burstSize: 8, emitEveryTicks: 1
+};
+
 export const parts = {
+  source1: [SphereEmitter, { ...SRC, center: [srcX, Math.round(cy - sep / 2)] }],
+  source2: [SphereEmitter, { ...SRC, center: [srcX, Math.round(cy + sep / 2)] }],
   // FAR-EDGE SINK. The plate below counts WITHOUT removing, so quanta fly on past
   // it; this is the experiment-boundary sink downstream of the plate. It is not
   // load-bearing (wrap is false, so the canvas edge would remove them anyway) — it
@@ -134,41 +163,11 @@ export const parts = {
 };
 
 export default function buildExperiment(exp) {
-  var NSRC = 2;
-  var lamArg = 3.2;                       // capacity/mass -> fullness 1/3.2 = 0.3125 (yellow)
-  var fwl    = 4 * (lamPx / lamArg);      // 400 -> wavelengthScale floor(400/4) = 100
-  var wlScale = Math.floor(fwl / 4);      // 100
   if (Math.abs(lamArg * wlScale - lamPx) > 1e-9) {
     throw new Error('[dse-h1] lamPx ' + lamPx + ' is not realisable as lambda_eff: the engine ' +
       'can only produce wavelengthArg x floor(fwl/4) = ' + (lamArg * wlScale) + '. (FAIL-LOUD.)');
   }
-  var cy   = Math.round(H / 2);           // 200 — the source plane's midline
-  // TWO-SOURCE SEPARATION. Two sources reinforce when their separation is a
-  // multiple of lambda/2, and the coupling falls as (lambda/d)^2, so lambda/2 is
-  // the strongest case. At this leg it also puts a band of EACH source on the
-  // midline y = H/2 (source 1's lower band and source 2's upper band coincide
-  // there) — the doubly-reinforced central peak, equidistant from both emitters,
-  // exactly where the one-source rung has no peak at all.
-  var sep  = lamPx / 2;                   // 160 -> sources at y 120 and 280
-  var srcYs = (NSRC === 2) ? [cy - sep / 2, cy + sep / 2] : [cy];
-  // ── THE LIGHT SOURCE ────────────────────────────────────────────────────
-  // preset 'hemisphere' = 180 degrees of FORWARD (+X) emission: the SAME
-  // ball-rejected sampler as the omni source with the forward axis' range halved,
-  // so nothing about the walk changes, it is simply pointed at the plate. The
-  // default emission box is 0 for this preset, so the source is a single PIXEL —
-  // load-bearing, because any spread at birth blurs every band by that spread.
-  // NO START WALL: the backward population is empty by construction, and `wrap` is
-  // false, so the canvas edge kills whatever transverse wiggle out-runs its
-  // forward component. One sink, not two.
-  var SRC = {
-    preset: 'hemisphere', is2D: true, chargeMode: 'random',
-    wavelength: lamArg, fundamentalDimension: 2, fundamentalWaveLength: fwl,
-    burstSize: 8, emitEveryTicks: 1
-  };
-  exp.createCanvas(CW, H, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  for (var si = 0; si < srcYs.length; si++) {
-    exp.addObject('SphereEmitter', Object.assign({}, SRC, { center: [srcX, Math.round(srcYs[si])] }));
-  }
+  exp.createCanvas(CW, H, SphereEmitter.worldCfg(parts.source1[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
   const p = exp.declare(parts);
   // ── THE INSTRUMENT — the live count-by-y histogram, REGISTERED TO THE PLATE ──
   // The panel takes the plate's OWN rect y-origin (0) and height (H), so the two

package/dist/frqtl/scenes/mirror-route.js

@@ -19,102 +19,119 @@
 // captured descriptor DATA) keeps the population bounded so FPS stays healthy, Restart-safe.
 //
 // ONE MODE-AWARE SOURCE. The mode strip selects the RENDERER the host boots
-// (renderState.renderer), and this scene reads it ONCE, before its world: `three` ⇒
+// (renderState.renderer), and this scene reads it ONCE, inside buildExperiment: `three` ⇒
 // exp.createScene (a 600x400x600 world), else exp.createCanvas (600x400). The ring geometry,
-// tilts, colours, laser and gate are the SAME in both modes (2D≡3D); `IS3D` guards exactly
-// these deltas:
+// tilts, colours, laser and gate are the SAME in both modes (2D≡3D). `parts` is written in the
+// 3D default mode, and flat2D (below) derives the 2D block from it — the scene's own statement of
+// two of its deltas:
 //   (a) every mirror is a 3D SLAB — a z-slab centred on the beam plane z=0, rendered as a plate;
 //   (b) the laser is VOLUMETRIC (is2D:false — it braids in y AND z; the slab depth catches the
-//       z-braid; its tilted xy faces reflect by the 2θ law, its near/far z-faces bounce vz);
+//       z-braid; its tilted xy faces reflect by the 2θ law, its near/far z-faces bounce vz).
+// `IS3D` guards the rest, in code after exp.declare:
 //   (c) two invisible destroy z-collimators flush with the slab z-band;
-//   (d) the population counter carries a z-slab covering the WHOLE universe z-band;
+//   (d) the population counter carries a z-slab covering the WHOLE universe z-band (the emitter's
+//       gateCounter names it, so it stays a code declaration);
 //   (e) MOVE/LOOK camera joysticks (the OMNI_3D pattern).
 // The 3D mode's render intent — god-rays at the sun's settings, computed from the light
 // particles only (godraySource 'leaf'), and the 'table-top' camera — rides the registry mode's
 // renderState (lib/shim/registry/walkthrough.js), whose god-ray VALUES are the sun's, owned by
 // lib/shim/render/sun-look.js.
 
-import { CameraControls, SphereEmitter } from '@descix/frqtl-web/parts';
+import { CameraControls, SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 import * as FrqtlDisplay from '@descix/frqtl-web/compat/renderer/display-slot.js';
 
-export const parts = {};
+const W = 600, H = 400, WORLD_D = 600;   // THE WORLD this scene states (its co-init call below)
+const f = Math.min(W, H) / 600;
+// R 225·f: adjacent decagon vertices sit 2R·sin18° ≈ 0.618R apart vs slab
+// height ~110·f, so the mirrors separate with clear gaps. Fit: R + rotated-slab half-diagonal
+// (≈55·f) stays inside min(W,H)/2 with margin.
+const CX = Math.round(W / 2), CY = Math.round(H / 2), R = Math.round(225 * f), HOP = 3, ROT = 12;
+// CAP 6400 / burst 8 (brightness retune): a VERY BRIGHT braid. The cap is
+// LIVE-controllable off the population counter (select 'population' in Layers → Inspector
+// 'Population Gate').
+const SW = Math.max(10, Math.round(14 * f)), SH = Math.max(70, Math.round(110 * f)), CAP = 6400;
+// SD — the 3D slab z-depth: a 2:1 tile (twice the slab height, z-centred on the beam plane).
+// The scene z-collimator clamps ALL quanta to this band, so every mirror provably faces every
+// alive quantum.
+const SD = 2 * SH;
+// Each mirror a DIFFERENT colour = its identity (a red→magenta rainbow); the recolor hook
+// stamps that colour onto every particle it reflects (string_map['render.color']).
+const PAL = [[255,60,60],[255,140,0],[255,220,0],[150,230,40],[40,210,90],[0,210,190],[0,170,255],[70,90,255],[150,70,235],[235,50,190]];
+// Hit-order vertices of the {10/3} star (m1..m10 named IN the order the beam visits them).
+const order = []; for (var k = 0; k < 10; k++) { order.push((k * HOP) % 10); }
+const D2R = Math.PI / 180;
+const vpos = function (v) { var a = (v * 36 + ROT) * D2R; return [CX + R * Math.cos(a), CY + R * Math.sin(a)]; };
+const pos = order.map(vpos);
+const deg = function (a) { return ((a * 180 / Math.PI) % 360 + 360) % 360; };
+const angOf = function (p, q) { return deg(Math.atan2(q[1] - p[1], q[0] - p[0])); };
+// Per-mirror IN-PLANE orientation from the in/out chords: ori = (in+out−180)/2, branch chosen
+// so the engine reflect law out = 180 + 2·ori − in reproduces the outgoing chord exactly.
+// Orientation is z-axis rotation, so the 3D slab depth adds NO new angle.
+const ORI = [];
+for (var j = 0; j < 10; j++) {
+  var pr = pos[(j + 9) % 10], cu = pos[j], nx = pos[(j + 1) % 10];
+  var inA = angOf(pr, cu), outA = angOf(cu, nx);
+  var o = (((inA + outA - 180) / 2) % 360 + 360) % 360;
+  var op = ((180 + 2 * o - inA) % 360 + 360) % 360;
+  if (Math.abs(((op - outA + 540) % 360) - 180) > 0.5) { o = (o + 90) % 360; }
+  ORI.push(o);
+}
+// The NARROW STRAIGHT-WALK laser (the exemplar): the SAME emitter as Rung 1
+// (Straight Walk) — preset 'particle-walk', every walk-character field INHERITED from the same
+// factory defaults (chargeMode 'positive', dim 0 = 'light' P=1, fundamentalWaveLength 64 → the
+// λ16 braided transverse ripple) — with ONLY the deliberate loop deltas: (a) a 2px source line
+// (emissionBoxSide 2 vs r1's default 10), (b) seated on the m10→m1 leg JUST CLEAR of m10 (70·f
+// past its vertex > the rotated-slab half-diagonal ≈55·f) and aimed along the leg (the longest
+// clear throw: leg 1.618R ≈ 364·f), (c) a burst of 8/tick, and (d) the DECLARED emission gate.
+const pS = pos[9], p0 = pos[0];
+const dx = p0[0] - pS[0], dy = p0[1] - pS[1], L = Math.hypot(dx, dy), ux = dx / L, uy = dy / L;
+const emit = [Math.round(pS[0] + 70 * f * ux), Math.round(pS[1] + 70 * f * uy)];
+// EMISSION-CAP GATE as DECLARED DATA (the blackbody-thermostat pattern):
+// emissionCap + gateCounter compile at CONSTRUCTION into a host tick-fn reading
+// Wall.getLiveCount on the background counter named 'population' (placed below — the by-name
+// reference resolves lazily on the first tick). The closed loop has NO sink, so the gate pauses
+// emission at the cap and resumes below it: the population plateaus. Restart-safe: the parts
+// writer keeps the two fields in the entry and the rebuilt emitter recompiles the gate (no free recipe tick-fn).
+// is2D: false (the 3D default) opens activeAxes.z — the volumetric laser; flat2D writes it true.
+// The parts, written in the 3D default mode (the mode strip's default): the laser, then the ten mirrors at the
+// star vertices — each its own colour + the recolor tag, each a 3D SLAB (z-slab -SD/2..SD/2). 2D is derived from
+// this block by flat2D below.
+export const parts = {
+  source: [SphereEmitter, { preset: 'particle-walk', is2D: false, center: emit, orientationDeg: angOf(pS, p0), emissionBoxSide: 2, burstSize: 8, emissionCap: CAP, gateCounter: 'population' }],
+  m1: [Wall, { rect: [Math.round(pos[0][0] - SW / 2), Math.round(pos[0][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[0], color: PAL[0], hooks: ['recolor'] }],
+  m2: [Wall, { rect: [Math.round(pos[1][0] - SW / 2), Math.round(pos[1][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[1], color: PAL[1], hooks: ['recolor'] }],
+  m3: [Wall, { rect: [Math.round(pos[2][0] - SW / 2), Math.round(pos[2][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[2], color: PAL[2], hooks: ['recolor'] }],
+  m4: [Wall, { rect: [Math.round(pos[3][0] - SW / 2), Math.round(pos[3][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[3], color: PAL[3], hooks: ['recolor'] }],
+  m5: [Wall, { rect: [Math.round(pos[4][0] - SW / 2), Math.round(pos[4][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[4], color: PAL[4], hooks: ['recolor'] }],
+  m6: [Wall, { rect: [Math.round(pos[5][0] - SW / 2), Math.round(pos[5][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[5], color: PAL[5], hooks: ['recolor'] }],
+  m7: [Wall, { rect: [Math.round(pos[6][0] - SW / 2), Math.round(pos[6][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[6], color: PAL[6], hooks: ['recolor'] }],
+  m8: [Wall, { rect: [Math.round(pos[7][0] - SW / 2), Math.round(pos[7][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[7], color: PAL[7], hooks: ['recolor'] }],
+  m9: [Wall, { rect: [Math.round(pos[8][0] - SW / 2), Math.round(pos[8][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[8], color: PAL[8], hooks: ['recolor'] }],
+  m10: [Wall, { rect: [Math.round(pos[9][0] - SW / 2), Math.round(pos[9][1] - SH / 2), SW, SH], z: -Math.round(SD / 2), depth: SD, collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[9], color: PAL[9], hooks: ['recolor'] }],
+};
+
+/** This scene's 2D delta, stated once: the same keys in the same order, each props copied with its z-slab
+ *  (z, depth) dropped and is2D written true where it is spelled. Pure; adds no key. */
+function flat2D(parts) {
+  const out = {};
+  for (const key of Object.keys(parts)) {
+    const props = Object.assign({}, parts[key][1]);
+    delete props.z;
+    delete props.depth;
+    if ('is2D' in props) { props.is2D = true; }
+    out[key] = [parts[key][0], props];
+  }
+  return out;
+}
 
 export default function buildExperiment(exp) {
   // The booted display (the host's renderState.renderer) decides which world this mode makes.
   var IS3D = FrqtlDisplay.name() === 'three';
-  var W = 600, H = 400, WORLD_D = 600;   // THE WORLD this scene states (its co-init call below)
-  var f = Math.min(W, H) / 600;
-  // R 225·f: adjacent decagon vertices sit 2R·sin18° ≈ 0.618R apart vs slab
-  // height ~110·f, so the mirrors separate with clear gaps. Fit: R + rotated-slab half-diagonal
-  // (≈55·f) stays inside min(W,H)/2 with margin.
-  var CX = Math.round(W / 2), CY = Math.round(H / 2), R = Math.round(225 * f), HOP = 3, ROT = 12;
-  // CAP 6400 / burst 8 (brightness retune): a VERY BRIGHT braid. The cap is
-  // LIVE-controllable off the population counter (select 'population' in Layers → Inspector
-  // 'Population Gate').
-  var SW = Math.max(10, Math.round(14 * f)), SH = Math.max(70, Math.round(110 * f)), CAP = 6400;
-  // SD — the 3D slab z-depth: a 2:1 tile (twice the slab height, z-centred on the beam plane).
-  // The scene z-collimator clamps ALL quanta to this band, so every mirror provably faces every
-  // alive quantum.
-  var SD = 2 * SH;
-  // Each mirror a DIFFERENT colour = its identity (a red→magenta rainbow); the recolor hook
-  // stamps that colour onto every particle it reflects (string_map['render.color']).
-  var PAL = [[255,60,60],[255,140,0],[255,220,0],[150,230,40],[40,210,90],[0,210,190],[0,170,255],[70,90,255],[150,70,235],[235,50,190]];
-  // Hit-order vertices of the {10/3} star (m1..m10 named IN the order the beam visits them).
-  var order = []; for (var k = 0; k < 10; k++) { order.push((k * HOP) % 10); }
-  var D2R = Math.PI / 180;
-  var vpos = function (v) { var a = (v * 36 + ROT) * D2R; return [CX + R * Math.cos(a), CY + R * Math.sin(a)]; };
-  var pos = order.map(vpos);
-  var deg = function (a) { return ((a * 180 / Math.PI) % 360 + 360) % 360; };
-  var angOf = function (p, q) { return deg(Math.atan2(q[1] - p[1], q[0] - p[0])); };
-  // Per-mirror IN-PLANE orientation from the in/out chords: ori = (in+out−180)/2, branch chosen
-  // so the engine reflect law out = 180 + 2·ori − in reproduces the outgoing chord exactly.
-  // Orientation is z-axis rotation, so the 3D slab depth adds NO new angle.
-  var ORI = [];
-  for (var j = 0; j < 10; j++) {
-    var pr = pos[(j + 9) % 10], cu = pos[j], nx = pos[(j + 1) % 10];
-    var inA = angOf(pr, cu), outA = angOf(cu, nx);
-    var o = (((inA + outA - 180) / 2) % 360 + 360) % 360;
-    var op = ((180 + 2 * o - inA) % 360 + 360) % 360;
-    if (Math.abs(((op - outA + 540) % 360) - 180) > 0.5) { o = (o + 90) % 360; }
-    ORI.push(o);
-  }
-  // The NARROW STRAIGHT-WALK laser (the exemplar): the SAME emitter as Rung 1
-  // (Straight Walk) — preset 'particle-walk', every walk-character field INHERITED from the same
-  // factory defaults (chargeMode 'positive', dim 0 = 'light' P=1, fundamentalWaveLength 64 → the
-  // λ16 braided transverse ripple) — with ONLY the deliberate loop deltas: (a) a 2px source line
-  // (emissionBoxSide 2 vs r1's default 10), (b) seated on the m10→m1 leg JUST CLEAR of m10 (70·f
-  // past its vertex > the rotated-slab half-diagonal ≈55·f) and aimed along the leg (the longest
-  // clear throw: leg 1.618R ≈ 364·f), (c) a burst of 8/tick, and (d) the DECLARED emission gate.
-  var pS = pos[9], p0 = pos[0];
-  var dx = p0[0] - pS[0], dy = p0[1] - pS[1], L = Math.hypot(dx, dy), ux = dx / L, uy = dy / L;
-  var emit = [Math.round(pS[0] + 70 * f * ux), Math.round(pS[1] + 70 * f * uy)];
-  // EMISSION-CAP GATE as DECLARED DATA (the blackbody-thermostat pattern):
-  // emissionCap + gateCounter compile at CONSTRUCTION into a host tick-fn reading
-  // Wall.getLiveCount on the background counter named 'population' (placed below — the by-name
-  // reference resolves lazily on the first tick). The closed loop has NO sink, so the gate pauses
-  // emission at the cap and resumes below it: the population plateaus. Restart-safe: codegen
-  // captures the two fields and the rebuilt emitter recompiles the gate (no free recipe tick-fn).
-  // is2D:!IS3D opens activeAxes.z in 3D — the volumetric laser.
-  var SRC = {
-    preset: 'particle-walk', is2D: !IS3D, center: emit, orientationDeg: angOf(pS, p0),
-    emissionBoxSide: 2, burstSize: 8,
-    emissionCap: CAP, gateCounter: 'population'
-  };
+  var P = IS3D ? parts : flat2D(parts);
   // THE WORLD — first, then parts: a 3D scene + universe (600x400x600) or a 2D canvas + universe.
-  if (IS3D) { exp.createScene(W, H, WORLD_D, SphereEmitter.worldCfg(SRC)); }
-  else      { exp.createCanvas(W, H, SphereEmitter.worldCfg(SRC)); }
-  exp.declare(parts);
-  exp.addObject('SphereEmitter', SRC);
-  // The ten mirrors at the star vertices — each its own colour + the recolor tag. In 3D each is a
-  // SLAB (z-slab −SD/2..SD/2); in 2D the bag is EMPTY, so the wall is the flat mirror.
-  var ZSLAB = IS3D ? { z: -Math.round(SD / 2), depth: SD } : {};
-  for (var i = 0; i < 10; i++) {
-    var p = pos[i];
-    exp.addObject('Wall', Object.assign(
-      { rect: [Math.round(p[0] - SW / 2), Math.round(p[1] - SH / 2), SW, SH] }, ZSLAB,
-      { collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[i],
-        name: 'm' + (i + 1), color: PAL[i], hooks: ['recolor'] }));
-  }
+  if (IS3D) { exp.createScene(W, H, WORLD_D, SphereEmitter.worldCfg(P.source[1])); }
+  else      { exp.createCanvas(W, H, SphereEmitter.worldCfg(P.source[1])); }
+  exp.declare(P);
   if (IS3D) {
     // SCENE Z-COLLIMATOR (without it the z lets things pass through instead of
     // reflecting): the legs' z-braid diffuses lap over lap; any quantum beyond the mirrors'

package/dist/shim/bundle/index.js

@@ -81,6 +81,12 @@ function _fromZip(bytes) {
         _fail('the archive carries ' + retired.join(' and ') + ': ' + RETIRED + '.');
     }
     if (names.indexOf(MANIFEST_FILE) === -1) {
+        var tops = names.map(function (n) { return n.split('/')[0]; }).filter(function (t, i, a) { return a.indexOf(t) === i; });
+        if (tops.length === 1 && names.indexOf(tops[0] + '/' + MANIFEST_FILE) !== -1 &&
+            names.every(function (n) { return n.indexOf(tops[0] + '/') === 0; })) {
+            _fail('the archive carries no ' + MANIFEST_FILE + ' at its root — the archive holds the folder `' + tops[0] + '/` rather ' +
+                'than its contents — zip the folder\'s CONTENTS (' + MANIFEST_FILE + ' at the root), as an Export writes it.');
+        }
         _fail('the archive carries no ' + MANIFEST_FILE + ' at its root — a project archive is the folder zipped ' +
             '(frqtl.json + sketch.js + …), as an Export writes it.');
     }

package/dist/shim/controls/index.js

@@ -101,7 +101,7 @@
 //   action — a MOMENTARY verb: {id,label,action} where `action` is a member of
 //            the closed ACTIONS vocabulary below. Stateless (no `value`, no
 //            read-back) and serializable by NAME, so a declared array of them
-//            round-trips through codegen with no new machinery. Actions are
+//            round-trips through the scene's text with no new machinery. Actions are
 //            deliberately NOT expressed as a `bind` — a bind is a property
 //            read/write pair, and `get()` of "restart" is meaningless.
 //

package/dist/shim/engine/artifact-shell.js

@@ -164,7 +164,7 @@ export function renderArtifactShellHtml(opts) {
     return (
 '<!DOCTYPE html>\n' +
 '<!-- Copyright 2023-2026 by Essam Abadir -->\n' +
-'<!-- FRQTL — claude.ai Artifact host shell (ws-artifact-showcase Bite A2).\n' +
+'<!-- FRQTL — claude.ai Artifact host shell.\n' +
 '     Generated by lib/shim/engine/artifact-shell.js — DO NOT hand-edit.\n' +
 '     Paste this ENTIRE file into a claude.ai chat as an Artifact (type: HTML). -->\n' +
 '<html lang="en">\n' +

package/dist/shim/engine/router.js

@@ -148,7 +148,7 @@ var DIST_PROFILE = buildDistProfile('../..');
 // lib/shim/engine/test/router.test.mjs asserts them against the two
 // package.json#version fields so a forgotten bump fails `make verify`, not a
 // silent stale-CDN-URL bug.
-var CDN_SDK_VERSION = '0.6.0-p4.1';  // sdk/frqtl-web/package.json#version (the ONE version owner) — bound by router.test.mjs
+var CDN_SDK_VERSION = '0.6.0';  // 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
 
 /**
@@ -382,7 +382,7 @@ function documentSiteBuild() {
 }
 
 // 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 (host-view.js::HOST_FRONT_PAGE),
+// index.html: a site's index.html is the publisher's front page (lib/shim/host/host-view.js::HOST_FRONT_PAGE),
 // which the IDE brand links home to.
 var STATIC_APP_PAGE = 'app.html';
 
@@ -507,7 +507,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.0-p4.1/dist/frqtl/compat/engine.js'
+ * // 'https://cdn.jsdelivr.net/npm/@descix/frqtl-web@0.6.0/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' });