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

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

@@ -662,12 +662,21 @@ import { libPathOf } from '../../../shim/project/specifiers.js';
         return { files: files, record: out.record, clips: out.clips };
     };
 
-    /** One act through the page's own doors: toSketch({by}), setDeclared(name, patch, {by}), placeDeclaredAt(name, point). */
+    /** rec.changes (the page's own read: a deep-frozen copy per read) as plain JSON. */
+    var _IN_PAGE_RECORD_CHANGES = function () {
+        var p = window.__frqtlHostedRecord;
+        if (!p || !p.rec) { throw new Error('[FrqtlHostedEyes/in-page] no Record is open — eyes.record.start() first.'); }
+        return JSON.parse(JSON.stringify(p.rec.changes));
+    };
+
+    /** One act through the page's own doors: toSketch({by}), setDeclared(name, patch, {by}), fork(name, Kind, {by}),
+     *  placeDeclaredAt(name, point). */
     var _IN_PAGE_ACT = async function (args) {
         var exp = window.FrqtlPage.experiment;
         var r = window.FrqtlPage.runner;
         if (args.door === 'toSketch') { return exp.toSketch(args.opts); }
         if (args.door === 'setDeclared') { return exp.setDeclared(args.name, args.patch, args.opts); }
+        if (args.door === 'fork') { return exp.fork(args.name, args.Kind, args.opts); }
         if (args.door === 'placeDeclaredAt') {
             var d = r.declared.find(function (o) { return o.name === args.name; });
             if (!d) { throw new Error('[FrqtlHostedEyes/in-page] no declared object is named ' + JSON.stringify(args.name) + '.'); }
@@ -1113,6 +1122,8 @@ import { libPathOf } from '../../../shim/project/specifiers.js';
              *   film(opts)   rec.film(opts) → its clip spans. Drive the world while it films:
              *                `const f = eyes.record.film(o); await eyes.driveToTick(n); await f`
              *   stop()       rec.stop() → { files: { path: string | Uint8Array }, record, clips } | { empty: true }
+             *   changes()    rec.changes → the rows so far, plain JSON (the page's own read). REJECTS when no Record is
+             *                open (as stop() does). One act's rows: read the length before the act, slice after.
              */
             record: {
                 start: function () {
@@ -1125,6 +1136,9 @@ import { libPathOf } from '../../../shim/project/specifiers.js';
                 },
                 stop: function () {
                     return page.evaluate(_IN_PAGE_RECORD_STOP, { modules: modules }).then(_rethrowRefused).then(_folderFromPage);
+                },
+                changes: function () {
+                    return page.evaluate(_IN_PAGE_RECORD_CHANGES);
                 }
             },
 
@@ -1132,11 +1146,13 @@ import { libPathOf } from '../../../shim/project/specifiers.js';
              * Acts through the page's own doors (the writer's rows come from these, never from node):
              *   toSketch({ by })                 exp.toSketch
              *   setDeclared(name, patch, { by }) exp.setDeclared
+             *   fork(name, Kind, { by })         exp.fork → { fork, file, from, files } (the files as text)
              *   placeDeclaredAt(name, [x, y, z?]) runner.placeDeclaredAt on the declared object of that name
              */
             act: {
                 toSketch: function (opts) { return page.evaluate(_IN_PAGE_ACT, { door: 'toSketch', opts: opts }); },
                 setDeclared: function (name, patch, opts) { return page.evaluate(_IN_PAGE_ACT, { door: 'setDeclared', name: name, patch: patch, opts: opts }); },
+                fork: function (name, Kind, opts) { return page.evaluate(_IN_PAGE_ACT, { door: 'fork', name: name, Kind: Kind, opts: opts }); },
                 placeDeclaredAt: function (name, point) { return page.evaluate(_IN_PAGE_ACT, { door: 'placeDeclaredAt', name: name, point: point }); }
             },
 

package/dist/frqtl/objects/objects/makeControlsForObject.js

@@ -254,8 +254,8 @@ function _resolveBounds(field, value) {
 
 function _label(field) {
     // An optional display `label` overrides the field NAME for the
-    // control's shown label WITHOUT renaming the schema field (the codegen/capture
-    // key stays `field.name`). e.g. leafDimension → "Emit Dimension", the global
+    // control's shown label WITHOUT renaming the schema field (the capture key
+    // stays `field.name`). e.g. leafDimension → "Emit Dimension", the global
     // shape capability → "Default Shape". Absent → the name, as before (byte-identical).
     var base = (typeof field.label === 'string' && field.label) ? field.label : field.name;
     return field.unit ? (base + ' (' + field.unit + ')') : base;
@@ -556,8 +556,8 @@ function _rectArrayHandler(field, env) {
             value: r.slice(),
             description: (field.description || '') +
                 ' (DISPLAY ONLY — the bind contract {object,prop} has no array-index ' +
-                'addressing; a live per-entry write needs either bind.index, a shim-contract ' +
-                'extension, or an onChange closure, forbidden this bite. See ' +
+                'addressing; a live per-entry write needs either bind.index or a shim-contract ' +
+                'extension (an onChange closure is not a bind). See ' +
                 'makeControlsForObject.js\'s module docstring, scope note #2.)'
         });
     }
@@ -730,7 +730,7 @@ function makeControlsForObject(wrapper, ctx, opts) {
         // field-name list) marks an ENGINE INTERNAL that must never surface as a
         // designer control/display (e.g. LargeObject.program's raw op-program AST,
         // the derived op-program-scope geometry accessors). Skipped entirely here —
-        // no control, no display row. Still engineVisible + captured for codegen.
+        // no control, no display row. Still engineVisible + captured by the parts writer.
         if (field.internal === true) { continue; }
         var handler = TYPE_DISPATCH[field.type];
         if (!handler) {

package/dist/frqtl/objects/record/Record.js

@@ -22,12 +22,20 @@
  *                            `closedBy: 'stop'`, or — when the facade's world is re-authored (a build of
  *                            text that is not the held text) — the folder of the world before, with
  *                            `closedBy: 'reauthor'` (rejected when that folder is refused, as stop() is).
+ *                            Both carry `droppedClips`: the clips still filming when the Record closed, which
+ *                            the close drops (0 on a stop, which refuses while a clip films); a refused
+ *                            re-author close carries it as err.droppedClips beside err.closedBy.
  *                            A refused close nobody READ (the getter records the read) makes the facade's
  *                            next exp.startRecord() reject, naming it.
  *   err.record               every rejection of stop() and of `closed` carries { changes, clips } — the
  *                            Record's rows and clip spans — so a host can name them unheld instead of losing them.
  *
- * `closedBy` and the clip spans are the host's (a lab's own `filmed` list); record.json never carries them.
+ * `closedBy`, `droppedClips` and the clip spans are the host's (a lab's own `filmed` list); record.json never
+ * carries them.
+ *
+ * An act (toSketch, setDeclared, fork) is ADMITTED only while the Record is open and not stopping (`_admit`, asked
+ * before the act changes the held text): an act during an async stop() is refused naming "stopping", and the
+ * held text is unchanged.
  *
  * WHERE ITS PARTS COME FROM — nothing here captures a second time:
  *   rows    the writer's own edits at act end (RecipeContext.toSketch / setDeclared call `_row`); only what
@@ -152,10 +160,20 @@ Record.requireBy = function (by, where) {
     return by;
 };
 
+/**
+ * THE admission check: an act may write into this Record only while it is open and not stopping. The facade asks
+ * it BEFORE an act changes the held text (toSketch, setDeclared, fork), and `_row` asks it again: one predicate.
+ * @private
+ */
+Record.prototype._admit = function (where) {
+    var at = where ? where + ': ' : '';
+    if (!this._open) { _fail(at + 'this Record is closed — no row is written into it.'); }
+    if (this._stopping) { _fail(at + 'this Record is stopping — an act during stop() belongs to the next Record.'); }
+};
+
 /** One change row, at the Record's current tick, in the order acted. @private */
 Record.prototype._row = function (row) {
-    if (!this._open) { _fail('this Record is closed — no row is written into it.'); }
-    if (this._stopping) { _fail('this Record is stopping — an act during stop() belongs to the next Record.'); }
+    this._admit();
     this._rows.push({ tick: this._tick, name: row.name, op: row.op, by: row.by, from: row.from, to: row.to });
 };
 
@@ -302,7 +320,7 @@ Record.prototype.stop = async function () {
     finally { this._stopping = false; }
     this._closedBy = 'stop';
     this._detach();
-    this._closedSettle.resolve(Object.assign({}, out, { closedBy: 'stop' }));
+    this._closedSettle.resolve(Object.assign({}, out, { closedBy: 'stop', droppedClips: 0 }));
     return out;
 };
 
@@ -312,13 +330,15 @@ Record.prototype.stop = async function () {
  */
 Record.prototype._closeOnReauthor = function (held) {
     var self = this;
+    var dropped = this._inflight;   // clips still filming: detaching drops them (their end() finds the Record closed)
     this._closedBy = 'reauthor';
     this._detach();
     this._folder(held).then(function (out) {
-        self._closedSettle.resolve(Object.assign({}, out, { closedBy: 'reauthor' }));
+        self._closedSettle.resolve(Object.assign({}, out, { closedBy: 'reauthor', droppedClips: dropped }));
     }, function (e) {
         self._refused = self._carry(e);
         self._refused.closedBy = 'reauthor';
+        self._refused.droppedClips = dropped;
         self._closedSettle.reject(self._refused);
     });
 };

package/dist/frqtl/objects/schema/engine-scopes.js

@@ -94,7 +94,7 @@ import * as FrameDataSchema from '../../../shim/frame-data/index.js';
                 engineVisible: true,
                 description: 'Frame center Z position (depth, physics pixels). ' +
                     'Default 0.0 when active_axes.z is false (2D mode). ' +
-                    'Bite 3 (ws-3d-discrete-walk): set by the 3D emitter; moved by the ' +
+                    'Set by the 3D emitter; moved by the ' +
                     'independent z yo-yo coin when active_axes.z is true. ' +
                     'Cube edge = w (spec §11 — no separate d field; cubes only).'
             },
@@ -322,7 +322,7 @@ import * as FrameDataSchema from '../../../shim/frame-data/index.js';
                 engineVisible: true,
                 description: 'Derived (scope-read): frame CENTER Z before this tick\'s move() ' +
                     '(physics pixels). Default 0.0 when active_axes.z is false. ' +
-                    'Bite 3 (ws-3d-discrete-walk): saved by Frame::move_frame alongside prev_x/prev_y. ' +
+                    'Saved by Frame::move_frame alongside prev_x/prev_y. ' +
                     'Read-only — write THROWS (engine-owned per-tick snapshot).'
             },
             // ── Forbidden: engine-owned topology ──────────────────────────────

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

@@ -273,7 +273,7 @@ export function shapeValuesMap() {
                 // existing scene is byte-identical. A live edit (updateObjectProperty) sets the
                 // per-instance override that _visibleLargeObjects reads.
                 description: 'When this object\'s visual shell renders (render-only): design = only ' +
-                    'while authoring (Bite-4b marker default); run = always visible (the "red light ' +
+                    'while authoring (the marker default); run = always visible (the "red light ' +
                     'bulb" opt-in); never = hidden. Generalizes the design-only marker suppression ' +
                     'at the single _visibleLargeObjects authority; engine collision is unaffected.'
             },
@@ -322,7 +322,7 @@ export function shapeValuesMap() {
                 // designer control — the raw JSON must never render in the STUDIO Inspector.
                 // `internal:true` is the ONE authority for "hide from the designer surface"
                 // (consumed by makeControlsForObject + AuthorView's renderInspector); the
-                // program is still engineVisible + captured for codegen/round-trip.
+                // program is still engineVisible + captured (the parts writer's round trip).
                 internal: true,
                 description: 'Op-program attached to this LO (§10.3 SLICE 3). ' +
                     'Shape: { on: "collision"|"tick", ops: [{ set: "<handle>.<prop>", to: ExprAST }] }. ' +

package/dist/frqtl/objects/setup/_worldInit.js

@@ -23,8 +23,7 @@
      *
      * The list is derived from what `initArgs()` below ACTUALLY reads. `interQuantumCollisions`
      * is in it because it is still ACCEPTED (inert — it fed a removed positional slot) and
-     * STUDIO codegen prints it into every saved recipe: dropping it from the vocabulary
-     * would make every saved scene throw.
+     * saved scenes carry it: dropping it from the vocabulary would make them throw.
      *
      * @type {Array<{key:string, effect:string}>}
      */

package/dist/frqtl/objects/setup/setupBlackbodySubstrate.js

@@ -34,8 +34,7 @@
  *   — as `lib/frqtl/scenes/blackbody.js` sets it.  ENGINE physics; no new
  *   op-programs.  Expected JS↔WASM divergence on parent-frame count (deferred §6).
  *
- * Set any flag to `false` only for progressive test isolation (L1/L2/L3 runs in
- * `experiments/blackbody-substrate/run.js`).  The default (all true) runs the
+ * Set any flag to `false` only for progressive test isolation (L1/L2/L3 runs).  The default (all true) runs the
  * scene's flags (brownian on, inter-quantum collisions on).
  *
  * ## Thermostat control loop (as-intended §2.1, Dispatch C2)

package/dist/frqtl/parts/CameraControls.js

@@ -177,6 +177,12 @@ import * as OrbitBag from '../compat/renderer/orbit-bag.js';
         if (mountEl && mountEl.__frqtlCameraHandle && mountEl.__frqtlCameraHandle.mounted) {
             return mountEl.__frqtlCameraHandle;
         }
+        // ...and per RUNNER: one runner has one camera controller. A host that mounted the pads before the scene
+        // could (STUDIO: the sizeless page builds before its runner has a control host), then a re-run in the same
+        // document (a fork, setDeclared) that reaches the scene's own attach with another container, gets the live one.
+        if (runner.__frqtlCameraHandle && runner.__frqtlCameraHandle.mounted) {
+            return runner.__frqtlCameraHandle;
+        }
 
         var doc = (mountEl && mountEl.ownerDocument) ? mountEl.ownerDocument
                 : (typeof document !== 'undefined' ? document : null);
@@ -581,6 +587,7 @@ import * as OrbitBag from '../compat/renderer/orbit-bag.js';
                 if (mountEl && mountEl.__frqtlCameraHandle === liveHandle) {
                     mountEl.__frqtlCameraHandle = null;
                 }
+                if (runner.__frqtlCameraHandle === liveHandle) { runner.__frqtlCameraHandle = null; }
                 if (rafId !== null) { cAF(rafId); rafId = null; }
                 // Force-release any in-flight joystick drag (detaches its doc listeners).
                 for (var i = 0; i < padCleanups.length; i++) {
@@ -617,6 +624,7 @@ import * as OrbitBag from '../compat/renderer/orbit-bag.js';
         };
         // F4: mark the container as owning this live instance (idempotency guard above).
         if (mountEl) { mountEl.__frqtlCameraHandle = liveHandle; }
+        runner.__frqtlCameraHandle = liveHandle;
         return liveHandle;
     }
 

package/dist/frqtl/parts/DetectorWall.js

@@ -111,7 +111,7 @@ import { registerKind } from '../objects/kinds.js';
         var depth = (opts.depth !== undefined && opts.depth !== null) ? opts.depth : null;
 
         this.universe = universe;
-        this._schemaKind = 'DetectorWall';
+        this._schemaKind = this.constructor.name;
 
         // The world rect, through the ONE normalizer (a zero-high detector counts nothing
         // and would report it as physics — so a missing dimension throws, never zeroes).

package/dist/frqtl/parts/GraphingDetectorWall.js

@@ -24,8 +24,8 @@
  * so every Wall option, live method and property accessor applies verbatim.
  * When neither `preset` nor `collisionBehavior` is supplied it defaults to the
  * `detector-screen` preset (destroy + count) — the counting authority. Extra
- * options, all DECLARED descriptor fields (so a codegen Restart round-trip
- * rebuilds the heatmap wall from captured state — the W2 declared-field rule):
+ * options, all DECLARED descriptor fields (so the parts writer captures them and the
+ * sketch rebuilds the heatmap wall from that state — the W2 declared-field rule):
  *
  *   @param {number} [opts.binPx=12]     — face bin size in physics pixels. Bins
  *     are anchored at the FACE ORIGIN (its top / near-z corner), so the map runs
@@ -105,7 +105,7 @@ import { registerKind, kindOf } from '../objects/kinds.js';
      * painting of the only spatial information a 2D scene carries.
      *
      * @param {Array|Object} rect — the LO rect ([l,t,w,h] / [l,t,z,w,h,d] /
-     *   {left,top,w,h[,z,d]} — the shape a codegen round-trip captures).
+     *   {left,top,w,h[,z,d]} — the shape a live LO's rect reads as).
      * @param {number} binPx
      * @returns {{top:number,height:number,z0:number,depth:number,binPx:number,
      *            canvasW:number,canvasH:number}}
@@ -248,9 +248,9 @@ import { registerKind, kindOf } from '../objects/kinds.js';
             opts = merged;
         }
         WallCls.call(this, universe, opts);
-        this._schemaKind = 'GraphingDetectorWall';
+        this._schemaKind = this.constructor.name;
 
-        // Declared heatmap fields (own props → codegen captureProps round-trip).
+        // Declared heatmap fields (own props → the parts writer's captureProps).
         this.binPx     = _num(opts.binPx, 12);
         this.refreshMs = _num(opts.refreshMs, 100);
         this.heatBase  = _num(opts.heatBase, 0.35);
@@ -399,8 +399,8 @@ import { registerKind, kindOf } from '../objects/kinds.js';
      *
      * FIELDS ARE FERRIED FROM WallDescriptor (never re-listed — the
      * schema-mirror-drift discipline): this descriptor is Wall's field table plus
-     * the three heatmap fields. Every one is a DECLARED field, so a codegen
-     * Restart round-trip rebuilds the heatmap wall from captured state.
+     * the three heatmap fields. Every one is a DECLARED field, so the parts writer
+     * captures it and the sketch rebuilds the heatmap wall from that state.
      */
     var WallDescriptor = kindOf(WallCls).descriptor;
     var GraphingDetectorWallDescriptor = {

package/dist/frqtl/parts/LargeObject.js

@@ -35,7 +35,7 @@ import { SCOPE_DESCRIPTORS } from '../objects/schema/scopes.js';
      * Build a LargeObject `.rect` for the 2D (4-element) case: a REAL Rectangle instance
      * (is_centered=false) so a center write (`.x`/`.y`) auto-recomputes left/top and vice
      * versa (PR-1 — audit item 3). A non-enumerable `toJSON` is attached so JSON-serializing
-     * consumers (codegen `_jsonCopy`, bundle export, save-state) still produce the SAME plain
+     * consumers (bundle export, save-state, any JSON copy) still produce the SAME plain
      * `{left,top,w,h}` shape they always did — the Rectangle's own enumerable fields are
      * `_left/_x/...`, which WOULD drift; `toJSON` pins the wire shape. (`left/top/w/h` are read
      * via getters by every direct consumer, so those are unaffected.) 6-element z/d rects are
@@ -128,7 +128,7 @@ import { SCOPE_DESCRIPTORS } from '../objects/schema/scopes.js';
         collectCollided = collectCollided || false;
 
         this.universe = universe;
-        this._schemaKind = 'LargeObject';
+        this._schemaKind = this.constructor.name;
         // rect is [left, top, w, h] (legacy) or [left, top, z, w, h, d] (FRQTL-MAINT
         // 2026-07-01, explicit z/depth) — is_centered=false convention either way.
         var ra = rectToArray(rect);

package/dist/frqtl/parts/LiveChart.js

@@ -267,8 +267,8 @@ import { registerKind } from '../objects/kinds.js';
             };
             // Mirror the SERIALIZABLE chartSpec fields onto the LO under their DESCRIPTOR
             // names (restart-bug fix, 2026-07-25): captureProps(lo, LiveChartDescriptor)
-            // reads lo[field.name], so without these mirrors a codegen round-trip (Save /
-            // Restart evals the generated module) silently rebuilt every chart UNBOUND
+            // reads lo[field.name], so without these mirrors a captured chart (the parts writer's
+            // capture of a declared chart) would rebuild UNBOUND
             // with default projector/label ("detector"). The name string — never the live
             // sourceHandle — is the captured source (re-resolved here on rebuild).
             lo.source    = sourceName;

package/dist/frqtl/parts/LogicGate.js

@@ -219,7 +219,7 @@ import { registerKind } from '../objects/kinds.js';
     function LogicGate(universe, opts) {
         opts = opts || {};
         this.universe = universe;
-        this._schemaKind = 'LogicGate';
+        this._schemaKind = this.constructor.name;
 
         var TunnelCls = _Tunnel;
         var WallCls = _Wall;
@@ -705,8 +705,8 @@ import { registerKind } from '../objects/kinds.js';
             var gate = new GateCls(ctx.runner.universe, opts);
             gate._schemaKind = Class.name;
             // The comparator is a HOST tick-fn: subscribe it to the runner's per-tick
-            // fan-out here, off the DECLARED fields, so the switching survives
-            // codegen → Restart (a recipe-authored tick-fn would be lost). Idempotent.
+            // fan-out here, off the DECLARED fields, so the switching belongs to the declared
+            // object: every build of it (a sketch entry, a Restart) re-wires it. Idempotent.
             if (typeof gate.attachToRunner === 'function') { gate.attachToRunner(ctx.runner); }
             return gate;
         }

package/dist/frqtl/parts/OvenBox.js

@@ -199,7 +199,7 @@ import { registerKind } from '../objects/kinds.js';
         options = options || {};
 
         this.universe = universe;
-        this._schemaKind = 'OvenBox';
+        this._schemaKind = this.constructor.name;
         this.name = options.name || 'oven';   // its declared name (the Tunnel/LogicGate idiom)
         this.temperature = options.temperature || 300;
 

package/dist/frqtl/parts/PointSource.js

@@ -169,7 +169,7 @@ import { declaredCount } from '../objects/ObjectFactory.js';
         var zDepth = opts.zDepth !== undefined ? opts.zDepth : null;
 
         this.universe = universe;
-        this._schemaKind = 'PointSource';
+        this._schemaKind = this.constructor.name;
         this.x = x;
         this.y = y;
         this.diameter = diameter;

package/dist/frqtl/parts/SlitLightSource.js

@@ -82,7 +82,7 @@ import { V1_REPLACEMENTS } from '../objects/v1-replacements.js';
         var zDepth = (depth !== null) ? depth : null;
 
         this.universe = universe;
-        this._schemaKind = 'SlitLightSource';
+        this._schemaKind = this.constructor.name;
 
         // Light source diameter: hardcoded to 16 matching devsdk's pointSOURCESIZE.
         // (wavelength * 0.25 * 2 = 32 would double the emission radius and velocity)

package/dist/frqtl/parts/SlitScreen.js

@@ -137,7 +137,7 @@ import { ObjectSchema } from '../objects/schema/index.js';
      */
     function SlitScreen(universe, wallLeft, wallWidth, canvasHeight, wavelength, absorbAtSlitWall, detectAtSlits, slitHeight, gapHeight, depth, holeDepth, linerScatter) {
         this.universe = universe;
-        this._schemaKind = 'SlitScreen';
+        this._schemaKind = this.constructor.name;
         this.wavelength = wavelength;
         this.depth = (depth !== undefined && depth !== null) ? depth : null;
         // 'current' (default/omitted) = today's exact liner behavior, byte-identical.

package/dist/frqtl/parts/SphereEmitter.js

@@ -157,7 +157,7 @@ import { CollisionTypes } from './CollisionTypes.js';
      * @param {Object} [opts]
      */
     function SphereEmitter(position, opts) {
-        this._schemaKind = 'SphereEmitter';
+        this._schemaKind = this.constructor.name;
         // First-arg overload: an array is a position; a plain object is opts
         // (position defaults to canvas center → byte-identical factory default).
         if (Array.isArray(position)) {
@@ -180,7 +180,7 @@ import { CollisionTypes } from './CollisionTypes.js';
         // self-throttle target — the emitter deactivates when the live population
         // measured by the counting Wall NAMED by `gateCounter` reaches the cap, and
         // reactivates below it. Compiled at CONSTRUCTION into a host tick-fn (see
-        // _installEmissionGate in addTo) so the gate is codegen-round-trippable and
+        // _installEmissionGate in addTo) so the gate is captured by the parts writer and
         // Restart-safe (the Restart-safe host-tick-fn rule — the gate is a
         // construction side effect of captured descriptor fields, exactly like the
         // ABSORB radiator, NEVER free recipe JS). Validation is throw-or-apply:
@@ -275,7 +275,7 @@ import { CollisionTypes } from './CollisionTypes.js';
      * `fn(universe)` seam — the SAME seam as the emit tick-fn, the blackbody
      * thermostat, and the ABSORB radiator). Each tick it:
      *   1. LAZILY resolves the counting Wall by NAME on the FIRST tick (handles are
-     *      registration-fresh and never survive codegen — the name is the reference;
+     *      registration-fresh and never survive a rebuild — the name is the reference;
      *      lazy resolution makes emitter/counter construction order irrelevant).
      *      Unresolved after the first tick → THROW (never a silent uncapped run).
      *   2. Reads the live population through `counter.getLiveCount(universe._lastTickData)`
@@ -447,7 +447,7 @@ import { CollisionTypes } from './CollisionTypes.js';
     // captureProps(sphereObj, SphereEmitterDescriptor) reads `sphereObj[field.name]`
     // DIRECTLY for every descriptor field (a getter satisfies it). These expose the
     // LIVE resolved value (from the factory's control) so a dragged/edited emitter
-    // Saves at its current state — the codegen round-trip authority. Boot-level fields
+    // Saves at its current state — what the parts writer captures. Boot-level fields
     // (fundamentalWaveLength) that the control doesn't surface read from the
     // construction opts (they cannot change live). `rect` is a WRITE-ONLY reposition
     // adapter: its getter is deliberately `undefined` so captureProps SKIPS it —
@@ -463,7 +463,7 @@ import { CollisionTypes } from './CollisionTypes.js';
         // the ObjectFactory marker diameter + makeControlsForObject's rect-seed. captureProps no
         // longer trips on this: the descriptor's rect field is `writeOnly:true`, so captureProps
         // SKIPS it by the descriptor flag (not by the getter being undefined) — `center` stays the
-        // single captured position authority (codegen round-trip unchanged). The write path
+        // single captured position authority. The write path
         // (rect → setCenter) is still the applyProp adapter (updateObjectProperty).
         get: function () {
             var c = (this._control && typeof this._control.getCenter === 'function')
@@ -487,7 +487,7 @@ import { CollisionTypes } from './CollisionTypes.js';
     Object.defineProperty(SphereEmitter.prototype, 'is2D',           _liveGetter(function (c) { return c.getIs2D(); }));
     Object.defineProperty(SphereEmitter.prototype, 'orientationDeg', _liveGetter(function (c) { return c.getOrientation(); }));
     Object.defineProperty(SphereEmitter.prototype, 'emissionBox',    _liveGetter(function (c) { return c.getEmissionBox(); }));
-    // Declared emission-gate fields (captured for codegen round-trip; undefined
+    // Declared emission-gate fields (captured by the parts writer; undefined
     // when uncapped → captureProps SKIPS them → byte-identical legacy scenes).
     Object.defineProperty(SphereEmitter.prototype, 'emissionCap', {
         get: function () { return this._emissionCap; }
@@ -585,7 +585,7 @@ import { CollisionTypes } from './CollisionTypes.js';
      * builder composes a LargeObject-visual marker + the factory's host emit
      * tick-fn (SU1 — the visual LO is NONE-collision, non-leaf, zero physics).
      *
-     * This descriptor is the SINGLE field authority: captureProps (codegen),
+     * This descriptor is the SINGLE field authority: captureProps (the parts writer),
      * makeControlsForObject (the Inspector), and FrqtlApp.updateObjectProperty
      * (the live-edit write path) ALL drive off it — no hand-list anywhere.
      *
@@ -600,7 +600,7 @@ import { CollisionTypes } from './CollisionTypes.js';
      *                round-trip; the Inspector just renders it read-only.
      *
      * FIELD SET is COMPLETE w.r.t. every scene-affecting setupSphereEmitter3D opt
-     * (a missing opt = lossy codegen). `emissionBoxSide` is subsumed by the
+     * (a missing opt = a lossy capture). `emissionBoxSide` is subsumed by the
      * captured derived `emissionBox`. There is no init flag: the SKETCH inits the
      * world once (setupSphereEmitter3D.initWorld / the co-init call), so a second emitter on
      * one universe (6A/6B/6C) is simply a second object.
@@ -635,7 +635,7 @@ import { CollisionTypes } from './CollisionTypes.js';
                 live: true,
                 // PR-1 item iii: the facade's `.rect` getter now returns a REAL rect DERIVED from
                 // the live center (so computeEntityBboxForDesign reads fresh — no stale bbox). To
-                // keep `center` the SINGLE captured position authority (codegen round-trip), this
+                // keep `center` the SINGLE captured position authority, this
                 // field is `writeOnly:true` → captureProps SKIPS it BY THE FLAG (not by the getter
                 // being undefined). The WRITE path is unchanged: a rect write maps rect-CENTER →
                 // the emission center (control.setCenter, via applyProp).
@@ -653,7 +653,7 @@ import { CollisionTypes } from './CollisionTypes.js';
                 engineVisible: false,
                 live: false,
                 description: 'Emission SOURCE POSITION in absolute canvas px as [x,y,z] (the captured ' +
-                    'position authority — codegen round-trips this, not rect). Edited live via the rect ' +
+                    'position authority — the parts writer writes this, not rect). Edited live via the rect ' +
                     'adapter / the visual marker drag; shown read-only here.'
             },
             {
@@ -698,7 +698,7 @@ import { CollisionTypes } from './CollisionTypes.js';
                 //    pattern; circulation-emission-gate-contract §2 field shapes).
                 //    Sensor = a placeable counting Wall (name in gateCounter); regulation =
                 //    emitter-side sugar compiled at CONSTRUCTION into a host tick-fn (the
-                //    Restart-safe host-tick-fn rule — codegen captures these two fields and
+                //    Restart-safe host-tick-fn rule — the parts writer captures these two fields and
                 //    the reconstructed emitter's constructor rebuilds the gate).
                 name: 'emissionCap',
                 type: 'number',
@@ -811,7 +811,7 @@ import { CollisionTypes } from './CollisionTypes.js';
                 constraint: { min: 0, integer: true },
                 engineVisible: false,
                 live: true,
-                // Field NAME stays `leafDimension` (codegen/capture key; a rename = round-trip
+                // Field NAME stays `leafDimension` (the capture key; a rename = round-trip
                 // break + a second name = schema mirror — Q-A2). The Inspector shows
                 // the display LABEL "Emit Dimension"; the write routes through applyProp →
                 // control.setLeafDimension (host-side addDimension + closure var flip; the NEXT

package/dist/frqtl/parts/Trace.js

@@ -245,7 +245,7 @@ import { Wall as _Wall } from './Wall.js';
     function Trace(universe, opts) {
         opts = opts || {};
         this.universe = universe;
-        this._schemaKind = 'Trace';
+        this._schemaKind = this.constructor.name;
 
         var path = opts.path;
         if (!Array.isArray(path) || path.length < 2) {

package/dist/frqtl/parts/Tunnel.js

@@ -239,7 +239,7 @@ import { setupTunnelPointExit } from '../objects/setup/setupTunnelPointExit.js';
     function Tunnel(universe, opts) {
         opts = opts || {};
         this.universe = universe;
-        this._schemaKind = 'Tunnel';
+        this._schemaKind = this.constructor.name;
 
         var left = opts.left, top = opts.top;
         var length = opts.length, bore = opts.bore;
@@ -307,7 +307,7 @@ import { setupTunnelPointExit } from '../objects/setup/setupTunnelPointExit.js';
                 'contention rather than the point source. (FAIL-LOUD.)');
         }
 
-        // Stash the authored construction values (the codegen round-trip authority —
+        // Stash the authored construction values (what the parts writer captures —
         // the descriptor fields read these back verbatim, Box precedent).
         this.left = left; this.top = top; this.length = length; this.bore = bore;
         this.wallThickness = wallThickness; this.axis = axis; this.color = color;
@@ -316,7 +316,7 @@ import { setupTunnelPointExit } from '../objects/setup/setupTunnelPointExit.js';
         // knob, so the Inspector must render its selector on every tunnel, which needs a
         // defined value to read. The three directed-only tunables follow the z/depth
         // OPT-IN precedent instead — left undefined in mirror mode so captureProps skips
-        // them and a mirror tunnel's codegen gains exactly ONE key, not four.
+        // them and a mirror tunnel's captured entry gains exactly ONE key, not four.
         this.mode = mode;
         if (directed) {
             this.directedAngle = directedAngleDeg;
@@ -331,9 +331,9 @@ import { setupTunnelPointExit } from '../objects/setup/setupTunnelPointExit.js';
             this.exitPhaseReset = exitPhaseReset;
         }
         // z/depth are DECLARED descriptor fields (TunnelDescriptor) so a 3D corridor
-        // round-trips through codegen/Restart. A FLAT (2D) tunnel leaves them
-        // `undefined` — captureProps skips undefined, so a 2D codegen stays
-        // byte-identical to the pre-3D output (no `"z":0,"depth":null` noise).
+        // round-trips through the parts writer. A FLAT (2D) tunnel leaves them
+        // `undefined` — captureProps skips undefined, so a 2D capture carries
+        // no `"z":0,"depth":null` noise.
         if (hasDepth) { this.z = z; this.depth = depth; }
 
         // ── Mirror wall rects (two parallel plates a `bore` apart) ───────────
@@ -734,9 +734,9 @@ import { setupTunnelPointExit } from '../objects/setup/setupTunnelPointExit.js';
      * Subscribe this tunnel's redirect to a runner's per-tick fan-out
      * (`FrqtlApp.addTickListener` — the multi-subscriber peer of the page's single
      * `onTick` slot, so it never steals it). Called by the ObjectFactory builder, which is
-     * what makes the directed mode survive codegen → Restart: the mode is a DECLARED
-     * descriptor field on the facade, so the rebuilt object re-wires itself. A raw tick-fn
-     * hand-written in a recipe would NOT survive (Restart evals the codegen'd module).
+     * what makes the directed mode part of the declared object: the mode is a DECLARED
+     * descriptor field on the facade, so every build of it (a sketch entry, a Restart)
+     * re-wires itself.
      *
      * Idempotent, and a no-op for a mirror tunnel or a runner without the fan-out.
      * @param {Object} runner - an FrqtlApp (needs `addTickListener`).
@@ -1045,8 +1045,8 @@ import { setupTunnelPointExit } from '../objects/setup/setupTunnelPointExit.js';
             // mode:'directed' — subscribe the host redirect to the runner's per-tick fan-out.
             // Self-gating + idempotent, so this is called unconditionally (a mirror tunnel
             // no-ops). Wiring it HERE, off the DECLARED `mode` field, is what makes the
-            // directed behavior survive codegen → Restart: the rebuilt facade re-subscribes
-            // itself, where a recipe-authored tick-fn would be lost.
+            // directed behavior part of the declared object: every build of the facade
+            // re-subscribes itself.
             if (typeof tunnel.attachToRunner === 'function') { tunnel.attachToRunner(ctx.runner); }
             return tunnel;
         }