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

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

@@ -13,9 +13,9 @@
  * Emits the CANONICAL spec: charge in raw form (0/1/'POSITIVE'/'NEGATIVE'/null).
  * All charge translation (numeric↔string) lives in the shim providers
  * (compat/providers/js-engine.js and compat/providers/wasm-engine.js).
- * No engine-sniffing above the shim (WS-A §2 invariant).
+ * No engine-sniffing above the shim (§2 invariant).
  *
- * chargeMode / random_direction (sugar-layer modes, WS emitter-modes-sugar):
+ * chargeMode / random_direction (sugar-layer modes, emitter-modes-sugar):
  *   chargeMode ∈ 'random' | 'positive' | 'negative' | 'both'
  *   random_direction ∈ boolean
  *
@@ -100,8 +100,8 @@ import { declaredCount } from '../ObjectFactory.js';
      * @param {number} quantum_limit - Max quanta to emit (Infinity = unlimited)
      * @param {number} delay - Ticks between bursts
      * @param {boolean} wrap - Wrap emitted particles at canvas boundaries.
-     * @param {Object} [opts] - ws-dse-3d AC1 (CEO drive #2 round-2 ruling, "the
-     *   emitter source mode consumes the SAME normalized SOURCE_SPEC bag"):
+     * @param {Object} [opts] - the
+     *   emitter source mode consumes the SAME normalized SOURCE_SPEC bag:
      *   `{ wavelength, zMin, zDepth, zIsotropy }` — the SAME trailing-`opts`
      *   idiom + the SAME field names/semantics `PointSource`'s own constructor
      *   already established for this EXACT emState contract (`emitterProgram.js`
@@ -154,13 +154,13 @@ import { declaredCount } from '../ObjectFactory.js';
         // colorOverride: render-only attribute for emitted particle color.
         // Set via updateObjectProperty(lo, 'colorOverride', [r,g,b]) from the IDE.
         this.colorOverride = null;
-        // renderShape / renderOutline (Bite 5b R3-1): render-only per-emitted-frame overrides,
+        // renderShape / renderOutline (R3-1): render-only per-emitted-frame overrides,
         // peers of colorOverride — the same per-frame reach SphereEmitter3D has. null default →
         // no key stamped (byte-identical). Threaded through the em spec → emitterProgram → the
         // makeLeafFrame WASM string_map merge stamp (render.shape / render.outline).
         this.renderShape = null;
         this.renderOutline = null;
-        // ws-dse-3d AC1: exposed for reads (round-trip save/restore, inspector) —
+        // Exposed for reads (round-trip save/restore, inspector) —
         // mutate via setWavelength(), never a bare assignment (mirrors vx/vy's
         // own setVelocity()-only-mutation discipline).
         this.wavelength = wavelength;
@@ -240,16 +240,16 @@ import { declaredCount } from '../ObjectFactory.js';
             wrap: !!tmpl.wrap,
             wavelength: tmpl.wavelength || null,
             fundamentalDim: null,   // null → engine uses the universe's fundamental-dim as the leaf level
-            // ws-dse-3d AC1: the SAME em.zMin/em.zDepth fields PointSource already
+            // The SAME em.zMin/em.zDepth fields PointSource already
             // wires (emitterProgram.js's existing opt-in z-spread mechanism) +
-            // em.zIsotropy (NEW field, this bite — gates the 3D unit-sphere
+            // em.zIsotropy (gates the 3D unit-sphere
             // random-direction draw). null/false (default) — byte-identical.
             zMin: (tmpl.zMin !== undefined && tmpl.zMin !== null) ? tmpl.zMin : null,
             zDepth: (tmpl.zDepth !== undefined && tmpl.zDepth !== null) ? tmpl.zDepth : null,
             zIsotropy: !!tmpl.zIsotropy,
         };
         var tickFn = buildEmitterTickFn(this.universe, em);
-        // Back-reference so dispose() (WS Studio Controls Realignment S4) can find
+        // Back-reference so dispose() (Studio Controls Realignment S4) can find
         // and splice OUT exactly the tick-fn(s) belonging to this emitter, without
         // needing a separate id→fn registry. Harmless extra property on a function.
         tickFn._emState = em;
@@ -469,8 +469,8 @@ import { declaredCount } from '../ObjectFactory.js';
     };
 
     /**
-     * ws-dse-3d AC1 (CEO drive #2 round-2 ruling, "the emitter source mode
-     * consumes the SAME normalized SOURCE_SPEC bag"): change per-emitted-particle
+     * The emitter source mode consumes the SAME normalized SOURCE_SPEC bag:
+     * change per-emitted-particle
      * wavelength (Engine Invariant #6 `mass=max(1,capacity/wavelength)`) LIVE —
      * mirrors `setVelocity`/`setBurstSize`'s own "write every handle" discipline
      * exactly (real state lives in `emState`, mutated ONLY by a dedicated setter
@@ -490,7 +490,7 @@ import { declaredCount } from '../ObjectFactory.js';
     };
 
     /**
-     * Reposition the emitter's single canonical source rect (WS Studio Controls
+     * Reposition the emitter's single canonical source rect (Studio Controls
      * Realignment S4, design §2.2/§2.5.5 — the "composite emitter move"
      * accessor). One path: mutates `source_rects` on the wrapper (inspector/
      * serializeDesign source of truth) AND every underlying emState's
@@ -519,8 +519,8 @@ import { declaredCount } from '../ObjectFactory.js';
     };
 
     /**
-     * Full teardown (WS Studio Controls Realignment S4, design item 1 — the
-     * CEO-found "delete leaves the emitter tick-fn running" defect). Stops this
+     * Full teardown (Studio Controls Realignment S4, design item 1 — the
+     * "delete leaves the emitter tick-fn running" defect). Stops this
      * emitter for good:
      *   1. Tombstones every underlying emState — `emitterProgram.js`'s
      *      `buildEmitterTickFn` checks `em.tombstoned` FIRST and returns `[]`

package/dist/frqtl/objects/objects/Tube.js

@@ -70,8 +70,8 @@
  *   end-caps then fall back to the legacy 4-element rect (z=0, depth=own-x-width;
  *   unaffected by this option, byte-identical to a z-open scene).
  * @param {number} [options.wallOpacity=0.3] - Render opacity 0 (fully transparent) to
- *   1 (fully opaque), applied to every wall (STANDARDIZED sugar-level knob, CEO
- *   2026-07-02 — so contained quanta stay visible from outside views). Reuses the
+ *   1 (fully opaque), applied to every wall (STANDARDIZED sugar-level knob,
+ *   so contained quanta stay visible from outside views). Reuses the
  *   existing LO `alpha` schema field (0-255; see the Render shape block below) —
  *   NOT a new render hint. The white edge outline stays crisp at any opacity.
  * @param {boolean} [options.collectCollided=false] - DIRECTED TUNNEL BUILD (2026-07-13):
@@ -102,7 +102,7 @@
  *       `randomDirection` (default false - a DIRECTED beam;
  *       true = an isotropic point-source INSIDE the bore, for a diffuse fill),
  *       `quantumLimit` (default Infinity), `delay` (default 0), `wrap` (default false).
- *     - `wavelength` (default null = engine default mass) - ws-dse-3d AC1: per-
+ *     - `wavelength` (default null = engine default mass) - per-
  *       emitted-particle wavelength override (`QuantumEmitter`'s own new `opts.
  *       wavelength`, Engine Invariant #6). LIVE via `this.emitter.setWavelength()`.
  *       When `zContain` is armed, this Tube ALSO auto-centres the emitter's z
@@ -117,7 +117,7 @@
  *   `options.emitter`).
  * @param {boolean} [options.sinkOpenEnds=false] - Build an ABSORB sink LO just beyond
  *   EACH open (uncapped) X-end — the reusable home for "the muzzle absorber-sink"
- *   (CEO 2026-07-02, L2.2): any open-ended contained-flow scene (a barrel firing gas
+ *   (L2.2): any open-ended contained-flow scene (a barrel firing gas
  *   out the muzzle, a wire/tunnel with through-traffic on both ends) wants a bounded
  *   population, not unbounded growth as frames exit and are never removed. Named
  *   generically (not `muzzleSink`) because Tube itself is generic (wire ≡ barrel ≡
@@ -125,7 +125,7 @@
  *   sink, at the open +X (muzzle) end; a wire (both ends open) gets two. Reuses the
  *   EXISTING KILL/ABSORB precedent (`DetectorWall.js`: `CollisionTypes.NONE` +
  *   `[COUNT, ABSORB]` actions, compiled by `actionCompiler.js`'s standard path to
- *   `set frame.is_alive = 0` — NOT `mass=0`, per the theorist's L1 note) — no new
+ *   `set frame.is_alive = 0` — NOT `mass=0`, per the L1 note) — no new
  *   op-program, no engine change. Each sink is invisible (`visible:false`) by
  *   default (a floating absorber box outside the bore reads as a rendering
  *   artifact, not a real object) but IS included in `this.largeObjects` (so the
@@ -212,11 +212,11 @@ import { QuantumEmitter } from './QuantumEmitter.js';
         var color    = options.color || [90, 90, 96];
         var observedDimensions = options.observedDimensions !== undefined ? options.observedDimensions : null;
         var zContain = options.zContain !== undefined ? !!options.zContain : true;
-        // wallOpacity: the STANDARDIZED render knob (CEO 2026-07-02) — see the Render
+        // wallOpacity: the STANDARDIZED render knob — see the Render
         // shape block below for the mechanism (reuses the existing LO `alpha` schema
         // field, lib/frqtl/objects/schema/index.js:166 — NOT a new hint).
         var wallOpacity  = options.wallOpacity  !== undefined ? options.wallOpacity  : 0.3;
-        // sinkOpenEnds: the muzzle-absorber-sink home (CEO 2026-07-02, L2.2) — see the
+        // sinkOpenEnds: the muzzle-absorber-sink home (L2.2) — see the
         // module docstring's param note. Default false — byte-identical to every
         // existing Tube consumer that doesn't
         // opt in.
@@ -321,13 +321,13 @@ import { QuantumEmitter } from './QuantumEmitter.js';
             ));
         }
 
-        // ── Open-end ABSORB sinks (CEO 2026-07-02, L2.2 — the muzzle-absorber-sink) ──
+        // ── Open-end ABSORB sinks (L2.2 — the muzzle-absorber-sink) ──────────────────
         // ONE sink per uncapped X-end (never on a capped end — a closed face already
         // contains everything; a sink there would be redundant and would fight the
         // wall's own bounce). REUSES the existing KILL/ABSORB precedent verbatim
         // (DetectorWall.js: CollisionTypes.NONE + [COUNT, ABSORB] actions, compiled by
         // actionCompiler.js's standard compileActions path to `set frame.is_alive = 0`
-        // — NOT mass=0, per the theorist's L1 note) — zero new op-program, zero engine
+        // — NOT mass=0, per the L1 note) — zero new op-program, zero engine
         // change. Positioned a small margin OUTSIDE the bore's open face (never
         // overlapping the interior, so normal bore physics near the opening is
         // unaffected) with the SAME z-slab (`faceRect`) every other face uses, so it
@@ -396,8 +396,8 @@ import { QuantumEmitter } from './QuantumEmitter.js';
             var esourceH = espec.sourceHeight !== undefined ? espec.sourceHeight : Math.max(1, Math.floor(interiorHeight / 2));
             var eEmitX = innerLeft + 2;
             var eCenterY = innerTop + interiorHeight / 2;
-            // ws-dse-3d AC1 (CEO drive #2 round-2 ruling, "the emitter source mode
-            // consumes the SAME normalized SOURCE_SPEC bag"): wavelength/z-centring/
+            // The emitter source mode consumes the SAME normalized SOURCE_SPEC bag:
+            // wavelength/z-centring/
             // z-isotropy — derived from THIS Tube's own `zContain`/`innerZ`/
             // `interiorDepth` (already in scope), never a caller burden. zContain
             // false (every pre-existing Tube.options.emitter caller) -> eZMin stays
@@ -421,17 +421,17 @@ import { QuantumEmitter } from './QuantumEmitter.js';
         }
 
         // ── Render shape (renderer-only hints; physics is unaffected) ────────────
-        // FRQTL-MAINT (2026-07-01, CEO-flagged): shape:'box' + depth wraps each wall LO
+        // FRQTL-MAINT: shape:'box' + depth wraps each wall LO
         // with a real 3D BoxGeometry (Bullet.js:112-116 precedent) instead of the
         // flat-plane default (_buildLoMesh, three-provider.js) — a zero-thickness plane
-        // reads as a thin 2D outline at oblique orbit angles, which is exactly the CEO's
+        // reads as a thin 2D outline at oblique orbit angles, which is exactly the
         // "walls draw as thin 2D outlines" finding. depth is read straight off the
         // wall's OWN rect.d (set above by the 6-element rect) so the box's z-extent
         // matches its true physical z-slab exactly; when zContain is false (legacy
         // 4-element rect, no rect.d), depth stays undefined and _buildLoMesh's existing
         // `lo.depth || lo.rect.w` fallback applies unchanged.
         //
-        // wallOpacity (CEO 2026-07-02, translucent walls so contained quanta stay
+        // wallOpacity (translucent walls so contained quanta stay
         // visible from outside): REUSES the existing `alpha` LO field — already a
         // first-class, schema-declared render-only property (`lib/frqtl/objects/schema/
         // index.js` name:'alpha', 0-255, widgetHint:'slider') that `_buildLoMesh`'s

package/dist/frqtl/objects/objects/absorbRadiation.js

@@ -3,19 +3,19 @@
 /**
  * absorbRadiation.js — ABSORB v2 on the LO's REAL backing-frame mass (Track A).
  *
- * CEO mass-surface ruling (Living Log 384ef5ee): use the OBJECT approach, not a
+ * The mass-surface rule: use the OBJECT approach, not a
  * duplicative op-prop mass surface. A LargeObject is backed by a REAL leaf Frame, so the
  * absorbed mass lands in a real frame's `mass` reachable through the SAME frame accessors
  * everything else uses.
  *
- * MANDATORY BACKING (CEO dry-realign 8d45fcdb): the backing frame is now created by the engine
+ * MANDATORY BACKING: the backing frame is now created by the engine
  * at `register_large_object` (every LO is frame-backed — no unbacked path). This sugar READS
  * that ledger via `getLargeObjectFrameId` instead of creating + attaching one.
  *
  * ── Layer 1: API contract ────────────────────────────────────────────────────
  * `attachAbsorberBackingFrame(universe, loHandle, rect, capacity)` → READS the LO's
  *   registration-created backing leaf (store-resident mass ledger — uninjected, zero
- *   single-occupancy / quadtree interaction, theorist §2a), primes it with the mass-1 empty
+ *   single-occupancy / quadtree interaction, §2a), primes it with the mass-1 empty
  *   baseline, and returns `{ backingFrameHandle, backingQid, level, capacity }`. `capacity` is
  *   the absorb CLOCK — the fill ceiling and the `1/capacity` emission probability — snapped to
  *   the nearest LEVEL the engine can actually size (`level` is that quantization's record).
@@ -41,8 +41,8 @@
  */
 
     /**
-     * The default radiating efficiency for an absorber that never sets one (CEO ruling
-     * 2026-08-11). A half-full leaf: it steps half the ticks and carries twice the wavelength
+     * The default radiating efficiency for an absorber that never sets one. A half-full
+     * leaf: it steps half the ticks and carries twice the wavelength
      * of a full one — a visibly "warm" re-emitter rather than a light-speed one.
      */
     var DEFAULT_EMISSIVITY = 0.5;
@@ -52,9 +52,9 @@
      * gate above 1, which cannot mean anything. FAIL LOUD rather than clamp: a silently
      * clamped 2.0 would look like it worked and quietly emit light-speed leaves.
      *
-     * NOTE (open, see the datasheet): 0 is REFUSED, not read as "never re-emit". The ruled mass
+     * NOTE (open, see the datasheet): 0 is REFUSED, not read as "never re-emit". The mass
      * law floors the emitted mass at 1, so a 0 could not actually suppress emission — accepting
-     * it would be a silent lie. A true perfect-absorber knob is a separate, unruled question.
+     * it would be a silent lie. A true perfect-absorber knob is a separate, open question.
      */
     function _validEmissivity(v, whence) {
         var n = Number(v);
@@ -71,7 +71,7 @@
      * the engine (`universe.levelCapacity`) rather than inverting `4^L` — which is the A={x,y}
      * answer only. Returns the smallest level whose real capacity covers the request, so the
      * clock never promises a ceiling the frame has no cells for. Minimum level 1 (an LO is a
-     * leaf frame at Dim>0, CEO round-2 (3)).
+     * leaf frame at Dim>0).
      */
     function deriveBackingLevel(universe, capacity) {
         var want = Math.max(1, Number(capacity) || 1);
@@ -174,11 +174,10 @@
          * at EACH layer in proportion to the mass it absorbed from that layer's collisions, so
          * conservation holds per layer and not merely in total.
          *
-         * PENDING CEO CONFIRM (orchestrator's interpretation of the CEO's direction, 2026-08-11): the
-         * proportion is drawn against each layer's UNRADIATED stored mass, which is what makes
-         * "in proportion to what it absorbed from that layer" exactly true in the ledger rather
-         * than only in expectation — a layer that has already given back everything it soaked
-         * stops being a candidate instead of borrowing another layer's mass.
+         * The proportion is drawn against each layer's UNRADIATED stored mass, so each layer's
+         * radiated total never exceeds what it absorbed (stored + radiated == absorbed per layer,
+         * in the ledger, not only in expectation) — a layer that has already given back
+         * everything it soaked stops being a candidate instead of borrowing another layer's mass.
          *
          * The draw is SKIPPED when only one layer is in play, so a single-layer world consumes
          * exactly the RNG stream it did before this rule existed.

package/dist/frqtl/objects/objects/actionCompiler.js

@@ -331,13 +331,13 @@ function _buildEjectOps(reposition, HANDLE_FRAME, HANDLE_SELF, Lit, Ref, Bin, Cm
         // collision trigger (intersects) is now 3D — only frames inside the LO's z-slab fire,
         // so a z-eject can never teleport a far-z frame.
         //
-        // WASM-ONLY PATH (architect Gate-2): the canonical Rust/WASM engine exposes z/near/far
-        // in the op scope bag; the FROZEN JS reference (EGPTfrqtl.js evalExpr) is 2D-only —
+        // WASM-ONLY PATH: the canonical Rust/WASM engine exposes z/near/far
+        // in the op scope bag; the FROZEN JS reference (its evalExpr) is 2D-only —
         // z/near/far read 0 there — so closest3d is exercised against WASM only. Conformance
         // C19 (lib/frqtl/conformance/collide_scenarios.cjs — a WASM-only oracle) covers it; do NOT
         // add closest3d to the JS-cross-checked suites (action_compiler_scenarios) without first
         // mirroring z/near/far into the JS-ref scope bag (which the frozen-fixture rule forbids).
-        // NIT-2 (architect, non-blocking, next substantive edit): factor the four x/y eject-position
+        // NIT-2 (non-blocking, next substantive edit): factor the four x/y eject-position
         // expressions (ejectLeft/Right/Top/Bottom) shared with the 'closest' branch above into one
         // helper; closest3d then adds only near/far + the 3-axis priority. Deferred to avoid
         // touching the green 'closest' path at closure.
@@ -447,12 +447,12 @@ function _buildVelocityFlipOp(loName, HANDLE_FRAME, Lit, Ref, Bin) {
 // added to `_buildEjectOps`/`_buildVelocityFlipOp` above. Tube.js builds these two extra
 // faces directly; the manual workaround is deleted, not kept alongside (DRY).
 
-// ── Collision LEXICON v2 builders (Collision Lab, CEO lexicon v2) ────────────────
+// ── Collision LEXICON v2 builders (Collision Lab, lexicon v2) ────────────────────
 //
 // These are ADDITIVE, pure op-program builders for the v2 wall vocabulary
 // (behavior nothing|block|bounce|absorb|destroy; bounceDirection reflect|random;
 // hooks mark|count). They compose the SAME closed NODE_KINDS the rest of this
-// file uses — ZERO engine change (theorist v2 advisory, all RUN-verified pkg-node).
+// file uses — ZERO engine change (v2 advisory, all RUN-verified pkg-node).
 // The existing compileActions() path is UNTOUCHED (byte-identity preserved); v2
 // callers (Wall.js via resolveWallSpec) go through compileWallV2() below.
 //
@@ -465,7 +465,7 @@ function _buildVelocityFlipOp(loName, HANDLE_FRAME, Lit, Ref, Bin) {
 //   NOT(x)                = Cond(x, 0, 1)
 
 /**
- * B2 — incidence-aware single-LO Reflect (CEO P1, RATIFIED). Replaces the W1
+ * B2 — incidence-aware single-LO Reflect. Replaces the W1
  * name-prefix flip (`_buildVelocityFlipOp` keyed on the LO NAME) with a Cond tree
  * over the frame's PREVIOUS position: the axis whose move carried the frame INTO
  * the wall this tick is the one whose velocity is inverted — the physical
@@ -523,7 +523,7 @@ function _buildIncidenceReflectOps(HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn) {
 }
 
 /**
- * Z1 — 3D incidence-aware Reflect (CEO UX-pass 2026-07-24; theorist Q2 PROVEN as the
+ * Z1 — 3D incidence-aware Reflect (Q2 PROVEN as the
  * op-data generalization on top of the landed prev_z scope-bag key — C26). The exact
  * 3-axis lift of `_buildIncidenceReflectOps`: adds the z-axis (near/far faces), flipping
  * whichever of the SIX faces' axis carried the frame INTO the wall's z-slab this tick.
@@ -591,7 +591,7 @@ function _buildIncidenceReflectOps3D(HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn) {
 }
 
 /**
- * R1 — ARBITRARY-ANGLE mirror reflection (CEO UX-pass ruling, theorist P3b PROVEN
+ * R1 — ARBITRARY-ANGLE mirror reflection (P3b PROVEN
  * EXACT). A mirror is a REFLECTION of the velocity about a mirror LINE at angle α
  * (the mirror SURFACE angle from horizontal, = the wall's `orientationDeg`):
  *
@@ -603,7 +603,7 @@ function _buildIncidenceReflectOps3D(HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn) {
  * genuine tilted mirror plane, so NO Cond-tree on the velocity part). Trig is legal
  * HOST-side at compile time (the SAME pattern the constrained-cone endpoints already
  * bake). Two-op sequential form (op2 reads the NEW vx written by op1, exploiting the
- * write-propagation into the scope bag — theorist v2 P3):
+ * write-propagation into the scope bag — v2 P3):
  *   op1: vx' = c2·vx + s2·vy                (reads both OLD values)
  *   op2: vy' = (s2/c2)·vx' − (1/c2)·vy_old  ≡ s2·vx_old − c2·vy_old   (exact)
  * Requires c2 = cos2α ≠ 0 (the α ≡ 45° mod 90° singularity routes to the exact swap
@@ -621,10 +621,10 @@ function _buildAngledReflectOps(HF, alphaDeg, Lit, Ref, Bin) {
 }
 
 /**
- * R1 — the α ≡ 45° mod 90° diagonal mirror, EXACT (theorist P1/P2 PROVEN). At these
+ * R1 — the α ≡ 45° mod 90° diagonal mirror, EXACT (P1/P2 PROVEN). At these
  * orientations cos2α = 0, so R(α) = [0, s2; s2, 0] with s2 = ±1 — the 2-op form above
  * divides by zero. The exact realization is the 3-op add/subtract SWAP (a naive
- * `vx=vy; vy=vx` is WRONG — the second op reads the already-overwritten vx; theorist
+ * `vx=vy; vy=vx` is WRONG — the second op reads the already-overwritten vx;
  * v2 P3), then a negate for the s2 = −1 branch:
  *   α ≡ 45° mod 180° (s2=+1): pure swap        vx' = vy,  vy' = vx      (+x → +y)
  *   α ≡ 135° mod 180° (s2=−1): swap + negate    vx' = −vy, vy' = −vx     (+x → −y)
@@ -656,7 +656,7 @@ function _buildSwapReflectOps(HF, alphaDeg, Lit, Ref, Bin) {
  *   • orientation ≡ 45 mod 90 (45/135/225/315) → the exact swap / swap+negate ops.
  *   • any other α → the 2-op host-baked-trig fixed-plane reflection.
  *
- * 3D ORIENTATION SCOPE (CEO ruling — keep to what the advisory PROVED): a non-cardinal
+ * 3D ORIENTATION SCOPE (kept to what the advisory PROVED): a non-cardinal
  * `orientationDeg` is orientation about the Z-AXIS (rotation in the xy-plane) — the 2D
  * swap/angled law LIFTED to a slab, with vz passing straight through (the beam's z-component
  * is untouched). This is the proven, exact case. FULL 3D orientation (a SECOND tilt angle —
@@ -685,7 +685,7 @@ function _buildReflectOps(orientationDeg, HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn,
             ? _buildIncidenceReflectOps3D(HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn)
             : _buildIncidenceReflectOps(HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn);
     }
-    // DRAWN-FACE REFLECTION (CEO 2026-07-25, Living Log 3d510a0a — supersedes the FIX-3
+    // DRAWN-FACE REFLECTION (supersedes the FIX-3
     // screenα=−orientationDeg guess). The mirror's reflecting surface is the LONG face of the
     // slab the renderer actually draws. The Wall mirror is a TALL slab (h > w): its long face
     // is VERTICAL at orientation 0, so a +x beam bounces straight back (−x) — EXACTLY what the
@@ -699,13 +699,13 @@ function _buildReflectOps(orientationDeg, HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn,
     // −o are congruent mod 180 ONLY at o ≡ 45 (mod 90), so R(−o) coincided with the drawn face
     // at 45/135/225/315 (and, via the separate incidence tree, at cardinals) but reflected a +x
     // beam to the OPPOSITE horizontal side at every OTHER angle (30/37/60/120/150…). That off-
-    // face deflection at non-45 tilt is the "reflection isn't correct all the time" the CEO saw
+    // face deflection at non-45 tilt is the "reflection isn't correct all the time" defect seen
     // when ROTATING the mirror. This change is BYTE-IDENTICAL at cardinals (untouched incidence
     // tree) and at 45/135/225/315 (90+o ≡ −o mod 180 ⇒ same swap ops), and corrects every
     // arbitrary angle for the tall mirror. NOTE (flagged, not fixed here): a WIDE mirror slab
     // (w > h, e.g. 1D mirrorB) has a HORIZONTAL long face (base 0, not 90); an aspect-blind law
     // cannot honor both bases — a wide mirror at a non-45 angle needs the aspect passed in, or
-    // the experiment retuned to a tall slab. See the deliverable's residual section.
+    // the experiment retuned to a tall slab.
     var alphaScreen = slab.reflectBaseDeg; // (90 + onorm) % 360 — from the ONE SlabFace authority.
     if (Math.abs(mod90 - 45) < EPS) {
         // 45/135/225/315 → exact swap (cos2α = 0 singularity of the 2-op form). For a 3D
@@ -718,8 +718,8 @@ function _buildReflectOps(orientationDeg, HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn,
 }
 
 /**
- * R1-GUARD — the ONE-SIDED FACE-CROSSING GUARD for a TILTED reflect mirror (theorist
- * red-team §2, MEASURED single-reflection optics; CEO 2026-07-25 drawn-face ruling).
+ * R1-GUARD — the ONE-SIDED FACE-CROSSING GUARD for a TILTED reflect mirror
+ * (red-team §2, MEASURED single-reflection optics; the drawn-face rule).
  *
  * ## Why this exists (the tilted-reflect LEAK-THROUGH the AABB trigger caused)
  *
@@ -749,10 +749,10 @@ function _buildReflectOps(orientationDeg, HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn,
  * Firing at the SURFACE (not the mid-line) means a beam reflects the moment it touches the
  * face the user SEES — and, fused with the same-tick face-normal exit eject below, a
  * reflected leaf is placed back OUTSIDE the slab in the SAME tick, so no post-tick snapshot
- * ever renders a reflected particle INSIDE the slab (CEO visual ruling, 2026-07-25: reflect
+ * ever renders a reflected particle INSIDE the slab (reflect
  * must reposition outside the collided edge in the same tick — particles seen rendering
  * inside the LO then walking through were the bug). The approach term (v·n sign) is what
- * kills the rattle the theorist MEASURED for a naive two-sided crossing test: after the
+ * kills the rattle MEASURED for a naive two-sided crossing test: after the
  * reflection v·n flips and the eject holds the leaf outside its incident surface, so neither
  * jitter re-crossings nor the reflected step satisfy the guard again. Handling BOTH surfaces
  * makes the wall a scene-agnostic two-faced mirror (a generic Wall never knows the beam's
@@ -844,7 +844,7 @@ function _buildTiltedReflectGuardTrigger(n, hw, HF, HS, Lit, Ref, Bin, Cmp, Cond
 
 /**
  * R1-GUARD eject — the PREV-ANCHORED FACE-NORMAL EXIT (the ONE eject story for a tilted
- * reflect; CEO same-tick-exteriority ruling, 2026-07-25). Places the leaf's WHOLE BODY just
+ * reflect; the same-tick-exteriority rule). Places the leaf's WHOLE BODY just
  * outside the slab on its INCIDENT side, in the SAME tick as the velocity flip:
  *
  *     P' = P_prev + (T − s(P_prev)) · n,     T = −sign(v·n) · (hw + w/2 + 1)
@@ -853,9 +853,9 @@ function _buildTiltedReflectGuardTrigger(n, hw, HF, HS, Lit, Ref, Bin, Cmp, Cond
  * guard requires it) and push along the face normal to clearance |s| = hw + w/2 + 1: half
  * slab thickness + half leaf width + 1px. The incident side is −sign(v·n) because the eject
  * ops run BEFORE the reflect ops, while v is still the INCOMING velocity. This supersedes
- * BOTH earlier stories: the plain prev-restore (theorist §2) only guaranteed the leaf was on
+ * BOTH earlier stories: the plain prev-restore (§2) only guaranteed the leaf was on
  * the incident side of the MID-LINE — a restored leaf could still sit up to hw INSIDE the
- * slab body and render there while walking out (the CEO saw exactly that); and the AABB
+ * slab body and render there while walking out (exactly the defect seen); and the AABB
  * 'closest' eject scattered or far-face-ejected (the original leak). Exit clearance holds for
  * the swap (45/135) AND arbitrary-angle paths identically — the ops are angle-generic data.
  *
@@ -864,7 +864,7 @@ function _buildTiltedReflectGuardTrigger(n, hw, HF, HS, Lit, Ref, Bin, Cmp, Cond
  * Both ops read ONLY `prev_x`/`prev_y`/`vx`/`vy` — refs that NEITHER op writes (and the
  * reflect ops, which run after, touch only vx/vy). So op1 (set x) and op2 (set y) evaluate
  * the IDENTICAL displacement Δ = T − s(P_prev) and land exactly at P_prev + Δ·n; s(P') = T
- * by construction. Compare the withdrawn OBB-normal eject (ae55c414), which computed s from
+ * by construction. Compare the withdrawn OBB-normal eject, which computed s from
  * the CURRENT x/y and needed a vz-scratch to survive its own eviction of x — a trick that
  * breaks on a 3D wall where vz is real momentum. prev-anchoring dissolves the problem.
  * WASM-only (prev_* scope family), like the cardinal incidence tree. z passes straight
@@ -957,8 +957,8 @@ function _tilted3DGates(n, hw, HF, HS, Lit, Ref, Bin, Cmp, Cond) {
 
 /**
  * R1-3D — the z-face EXIT eject for a 3D tilted slab: place the leaf's whole body just
- * outside the z-face it entered through, in the SAME tick as the vz flip (the CEO
- * same-tick-exteriority ruling, z-lifted):
+ * outside the z-face it entered through, in the SAME tick as the vz flip (the
+ * same-tick-exteriority rule, z-lifted):
  *     z' = cz + sign(prev_z − cz) · (hz + w/2 + 1)
  * with cz/hz derived LIVE from `self.near`/`self.far` (the engine-recentered z-band —
  * the broad-phase superset rect widens only x/y, so near/far are the TRUE z-faces) and
@@ -988,7 +988,7 @@ function _gateOps(ops, gateFactory, HF, Ref, Cond) {
     });
 }
 
-// ── PITCHED (two-axis) mirror builders — CEO ruling 2026-07-26 (Living Log ce4fb0c9) ──
+// ── PITCHED (two-axis) mirror builders ───────────────────────────────────────────
 //
 // A PITCHED plate (pitchDeg ≠ 0 about its own long axis) reflects by the TRUE 3-space law
 // R = I − 2nnᵀ about the plate normal n (SlabFace plate3.n — the ONE authority). This
@@ -1135,7 +1135,7 @@ function _buildPitchedExitEjectOps(plate, HF, HS, Lit, Ref, Bin, Cmp, Cond) {
 }
 
 /**
- * B3 — omni direction-only Random (CEO round-2 (a)): redraw the exit direction
+ * B3 — omni direction-only Random: redraw the exit direction
  * uniformly over the square, DIRECTION ONLY, NO decoherence. This is also the
  * round-1 half-plane fix (the legacy RANDOM_XY drew vx ∈ [0,1) = forward hemisphere).
  * Uniform-over-square (not angle-uniform — ops cannot loop ⇒ no in-tick rejection);
@@ -1150,10 +1150,10 @@ function _buildOmniRandomOps(HF, Lit, Bin, Fn) {
 }
 
 /**
- * B3 — angle-CONSTRAINED Random (CEO round-2 (b)): redraw the exit direction over a
+ * B3 — angle-CONSTRAINED Random: redraw the exit direction over a
  * cone bounded by two endpoint direction vectors A=(ax,ay), B=(bx,by), computed
  * HOST-SIDE from the wall's INITIAL orientation + [minDeg,maxDeg] and BAKED as Lits
- * (immune to later spin by construction — a re-aim must recompile). Uses the theorist
+ * (immune to later spin by construction — a re-aim must recompile). Uses the
  * single-draw scratch-prop trick (proven P3, 60/60 exact on the consistency law):
  * every Fn('random') is a fresh draw, so store ONE t in a scratch prop (frame.vx),
  * read it in BOTH lerps. op2 (vy) reads t BEFORE op3 (vx) overwrites it. 1 RNG draw.
@@ -1174,10 +1174,10 @@ function _buildConstrainedRandomOps(HF, ax, ay, bx, by, Lit, Ref, Bin, Fn) {
 }
 
 /**
- * B3 — decoherence as an INDEPENDENT toggle (CEO round-2 (c)): the phase reset
+ * B3 — decoherence as an INDEPENDENT toggle: the phase reset
  * (`local_time=0`, offset-decoherence) + charge redraw (sign-decoherence, bench Q1)
  * that the legacy RANDOM_XY bundled in — here SEPARABLE, stackable onto any behavior.
- * Proven separable (theorist P1/P2). 1 RNG draw (charge). @returns {Array<object>}
+ * Proven separable (P1/P2). 1 RNG draw (charge). @returns {Array<object>}
  */
 function _buildDecoherenceOps(HF, Lit, Cmp, Cond, Fn) {
     return [
@@ -1186,9 +1186,9 @@ function _buildDecoherenceOps(HF, Lit, Cmp, Cond, Fn) {
     ];
 }
 
-// ── ABSORB v2 tally — WITHDRAWN (theorist round-3, CEO 384ef5ee) ─────────────────
-// The v1 `count`-as-virtual-mass tally op was the duplicative parallel LO-prop surface
-// the CEO's mass-surface ruling rejected. ABSORB v2 now accumulates into the LO's REAL
+// ── ABSORB v2 tally — WITHDRAWN (round-3) ────────────────────────────────────────
+// The v1 `count`-as-virtual-mass tally op was a duplicative parallel LO-prop surface,
+// which the mass-surface rule rejects. ABSORB v2 now accumulates into the LO's REAL
 // backing-frame mass via the existing frame accessors (the "LO extends Frame" composition;
 // under MANDATORY BACKING the LO's backing frame is created at registration and READ via
 // getLargeObjectFrameId) — see `absorbRadiation.js`. The compileWallV2 absorb branch
@@ -1209,7 +1209,7 @@ function _buildDecoherenceOps(HF, Lit, Cmp, Cond, Fn) {
  *     native dispatch_collision_type draw order: velocity first, then reset() charge)
  *   - MOMENTUM_BASED and WALL draw 0 RNG values
  *
- * ## RNG discipline (from EGPTfrqtl.js native dispatch, MUST MATCH):
+ * ## RNG discipline (from the JS reference's native dispatch, MUST MATCH):
  *
  *   RANDOM_X:   1 draw  — vx = _rng()*2-1, vy = 1 (no charge draw)
  *   RANDOM_Y:   2 draws — vy = _rng()*2-1, then reset() draws _rng() for charge
@@ -1220,7 +1220,7 @@ function _buildDecoherenceOps(HF, Lit, Cmp, Cond, Fn) {
  *                         is a no-op here (action already compiled)
  *   NONE:       0 draws — nothing emitted
  *
- * ## charge draw (reset(), EGPTfrqtl.js:2564)
+ * ## charge draw (reset())
  *   `_rng() < 0.5 ? Charge.POSITIVE : Charge.NEGATIVE`
  *   AST: Cond(Cmp('<', Fn('random',[]), Lit(0.5)), Lit(0), Lit(1))
  *   (0 = POSITIVE, 1 = NEGATIVE in both JS and Rust)
@@ -1364,7 +1364,7 @@ function compileActions(actions, loName, reposition, collisionType) {
 
     if (ct === 'RANDOM_X') {
         // RANDOM_X: 1 RNG draw — vx = _rng()*2-1, vy = 1 (no charge reset).
-        // Native (EGPTfrqtl.js:1155-1165): vx = _rng()*2-1; vy = 1;
+        // Native: vx = _rng()*2-1; vy = 1;
         ops.push({ set: HANDLE_FRAME + '.vx',
                    to: Bin('-', Bin('*', Fn('random', []), Lit(2)), Lit(1)) });
         ops.push({ set: HANDLE_FRAME + '.vy',
@@ -1372,7 +1372,7 @@ function compileActions(actions, loName, reposition, collisionType) {
 
     } else if (ct === 'RANDOM_Y') {
         // RANDOM_Y: 2 RNG draws — vy = _rng()*2-1, then reset() draws charge.
-        // Native (EGPTfrqtl.js:1167-1175): vy = _rng()*2-1; vx = 1; reset() → charge draw.
+        // Native: vy = _rng()*2-1; vx = 1; reset() → charge draw.
         // reset() also clears local_time=0 (wave-phase reset — G2 mirrors this with a 0-draw op).
         ops.push({ set: HANDLE_FRAME + '.vy',
                    to: Bin('-', Bin('*', Fn('random', []), Lit(2)), Lit(1)) });
@@ -1386,7 +1386,7 @@ function compileActions(actions, loName, reposition, collisionType) {
 
     } else if (ct === 'RANDOM_XY') {
         // RANDOM_XY: 3 RNG draws — vx = _rng(), vy = _rng()*2-1, then reset() draws charge.
-        // Native (EGPTfrqtl.js:1155-1170): vx = _rng(); vy = _rng()*2-1; reset() → charge.
+        // Native: vx = _rng(); vy = _rng()*2-1; reset() → charge.
         // reset() also clears local_time=0 (wave-phase reset — G2 mirrors this with a 0-draw op).
         ops.push({ set: HANDLE_FRAME + '.vx',
                    to: Fn('random', []) });
@@ -1475,7 +1475,7 @@ function compileActions(actions, loName, reposition, collisionType) {
  *   @param {Array<number>} [spec.angleConstraint] - [minDeg,maxDeg] offsets around the
  *       wall's INITIAL orientation (random only). Omitted/full ⇒ omni.
  *   @param {number} [spec.orientationDeg=0]- the wall's INITIAL orientation (baked; a
- *       later spin must recompile, per CEO — the cone endpoints are compile-time Lits).
+ *       later spin must recompile — the cone endpoints are compile-time Lits).
  *   @param {boolean}[spec.decoherence=false]- append the phase/charge reset (random only).
  *   @param {Array<string>}[spec.hooks]     - ['mark','count'] (composable with any behavior).
  *   @param {string} [spec.markTag]         - the user string MARK stamps (default '').
@@ -1523,11 +1523,11 @@ function compileWallV2(spec) {
     var ops = [];
 
     // ── Motion / life response (the ONE behavior axis) ───────────────────────
-    // TILTED REFLECT GUARD (theorist §2 + CEO same-tick-exteriority ruling, 2026-07-25): a
+    // TILTED REFLECT GUARD (§2 + the same-tick-exteriority rule): a
     // NON-cardinal REFLECT mirror is fired ONCE per genuine drawn-SURFACE crossing (the guard
     // trigger, applied below) and ejects by the PREV-ANCHORED FACE-NORMAL EXIT — the ONE
-    // coherent eject story that replaces BOTH the interim OBB-normal eject (ae55c414) and the
-    // theorist's plain prev-restore. Cardinal / random-bounce / non-reflect walls keep the
+    // coherent eject story that replaces BOTH the interim OBB-normal eject and the
+    // plain prev-restore. Cardinal / random-bounce / non-reflect walls keep the
     // AABB 'closest' eject + plain-intersects trigger — BYTE-IDENTICAL (SU1). The guard normal
     // is CONSUMED from the ONE SlabFace authority (obb.normal = the −1-eigenvector the reflect
     // law flips, engine y-down frame) — never a second inline sin/cos convention. Applies to
@@ -1539,7 +1539,7 @@ function compileWallV2(spec) {
         ? SlabFace.resolveSlabFace({ orientationDeg: spec.orientationDeg,
                                            w: spec.slabW, h: spec.slabH,
                                            pitchDeg: spec.pitchDeg, d: spec.slabD }) : null;
-    // R2AX — a PITCHED plate (two-axis mirror, CEO ruling 2026-07-26) takes the true
+    // R2AX — a PITCHED plate (two-axis mirror) takes the true
     // 3-space reflection path (R = I − 2nnᵀ about SlabFace plate3.n + the n-dot guard +
     // the prev-anchored 3-space exit). pitch 0/absent never sets `pitched` — every
     // existing program stays byte-identical.
@@ -1619,7 +1619,7 @@ function compileWallV2(spec) {
         // legacy `CollisionActions.BLOCK` compiled — so porting a legacy `block` caller
         // moves ZERO physics.
         //
-        // WHY "closest outside" and NOT "revert the last move" (the CEO gave both options;
+        // WHY "closest outside" and NOT "revert the last move" (both were options;
         // measured head-to-head on the canonical WASM engine, wall x∈[200,220]):
         //   - approaching leaf (x=150, vx=+1): the two are equivalent in outcome — the leaf
         //     stops dead at the face and stays (eject parks at x=198.5, revert at x=199) for
@@ -1641,11 +1641,11 @@ function compileWallV2(spec) {
         var blockEjectOps = _buildEjectOps(reposition, HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn) || [];
         for (var bq = 0; bq < blockEjectOps.length; bq++) { ops.push(blockEjectOps[bq]); }
     } else if (behavior === 'absorb') {
-        // Track A (CEO mass-surface ruling 384ef5ee): the collision op just KILLS; the host
+        // Track A (the mass-surface rule): the collision op just KILLS; the host
         // radiation tick-fn (absorbRadiation.js) tallies the collected killed masses into the
         // LO's REAL BACKING-FRAME mass (via the existing frame accessors) and radiates per the
-        // conservation contract. The v1 count-as-virtual-mass tally op is WITHDRAWN (theorist
-        // round-3 — it was exactly the duplicative parallel surface the CEO flagged).
+        // conservation contract. The v1 count-as-virtual-mass tally op is WITHDRAWN (round-3
+        // — it was exactly the duplicative parallel surface the rule rejects).
         var cap = (typeof spec.capacity === 'number' && spec.capacity > 0) ? spec.capacity : 64;
         ops.push({ set: HF + '.is_alive', to: Lit(0) });
         collectCollided = true;          // buffer killed frames' masses for the host tally
@@ -1700,8 +1700,8 @@ function compileWallV2(spec) {
                 _reflectSlab.plate3, HF, HS, Lit, Ref, Bin, Cmp, Cond, Fn));
         } else if (tiltedReflect) {
             // GUARDED tilted reflect: fire the reflection ONCE per drawn-SURFACE crossing
-            // (surface-crossing + approach guard — theorist §2 upgraded to the ±hw surfaces
-            // per the CEO same-tick-exteriority ruling). The crossing NORMAL is `obb.normal`
+            // (surface-crossing + approach guard — §2 upgraded to the ±hw surfaces
+            // per the same-tick-exteriority rule). The crossing NORMAL is `obb.normal`
             // and the half-thickness `obb.hw`, BOTH from the ONE SlabFace authority: the
             // normal is the axis R(reflectBaseDeg) actually FLIPS (its −1-eigenvector,
             // engine y-down frame) — the SAME derivation the reflect law, the renderer's
@@ -1725,8 +1725,8 @@ function compileWallV2(spec) {
 
 // ── Export ─────────────────────────────────────────────────────────────────────
 
-// Collision LEXICON v2 builders (theorist-proven; consumed by compileWallV2 and driven RAW by the bench
-// LO-bites — the SINGLE authority for these shapes) and the shared eject/flip builders (OvenBox, Tube).
+// Collision LEXICON v2 builders (proven; consumed by compileWallV2 and driven RAW by the bench
+// LO behaviors — the SINGLE authority for these shapes) and the shared eject/flip builders (OvenBox, Tube).
 export {
     compileActions,
     compileWallV2,