@woosh/meep-engine 3.28.0 → 3.29.0

package/src/shade/renderer/GraphicsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAkCA;IA2JI,yBA+BC;IAzLD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAmCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAeC;IAED,4BAEC;IAED,eAmBC;IAED,gBAeC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BAtVY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAZzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAehD,6BAA6B;sCACtB,4CAA4C;iCAdjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;2CADtC,wCAAwC;oCAQ/C,kCAAkC;iCATtB,8BAA8B"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAkCA;IA2JI,yBA+BC;IAzLD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAmCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAeC;IAED,4BAEC;IAED,eAyBC;IAED,gBAeC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BA5VY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAZzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAehD,6BAA6B;sCACtB,4CAA4C;iCAdjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;2CADtC,wCAAwC;oCAQ/C,kCAAkC;iCATtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -330,6 +330,12 @@ export class GraphicsContext {
     update() {
         const command_ctx = ShadeGPUCommandContext.create(this, 'GraphicsContext.update');
 
+        // The one place per frame the meshlet pool compacts, at the head of the frame: before the
+        // clone flush in geometries.update, before the VG runtime's flush, before any pass. Its
+        // per-frame bound is a bound because this is the only call (COMPACTION_PLAN_2026_09_16
+        // §4.5).
+        this.geometries.meshlets.sweep(command_ctx);
+
         this.geometries.update(command_ctx);
 
         this.textures.update();

package/src/shade/renderer/Renderer.d.ts

@@ -71,6 +71,8 @@ export class Renderer {
      * @type {boolean}
      */
     feature_tetrahedron_point_shadows: boolean;
+    set shadow_update_budget(v: number);
+    get shadow_update_budget(): number;
     feature_bloom_enabled: boolean;
     feature_automatic_exposure_enabled: boolean;
     set exposure_compensation(v: number);

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -75,6 +75,7 @@ import { graph_image_pass } from "./shader/graph/graph_image_pass.js";
 import { graph_import_buffer } from "./shader/graph/graph_import_buffer.js";
 import { graph_import_texture } from "./shader/graph/graph_import_texture.js";
 import { ShadeUpscalerType } from "./ShadeUpscalerType.js";
+import { DEFAULT_SHADOWMAP_UPDATE_BUDGET } from "./shadow/map/DEFAULT_SHADOWMAP_UPDATE_BUDGET.js";
 import { CascadedSceneSDF } from "./shadow/sdf/cascade/CascadedSceneSDF.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "./STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { GPUTextureContext } from "./texture/GPUTextureContext.js";
@@ -226,6 +227,26 @@ export class Renderer {
      * @type {boolean}
      */
     feature_tetrahedron_point_shadows = false;
+
+    /**
+     * Views the shadow refresh scheduler may spend per frame, pushed to the scene's shadow context
+     * each frame; see {@link DEFAULT_SHADOWMAP_UPDATE_BUDGET} for what a view costs and
+     * {@link GPUSceneShadowmapContext.update_budget} for what spends it. Raising it keeps more
+     * lights current at the cost of more shadow rasterization per frame.
+     * @type {number}
+     */
+    #shadow_update_budget = DEFAULT_SHADOWMAP_UPDATE_BUDGET;
+
+    set shadow_update_budget(v) {
+        assert.isPositiveInteger(v, 'shadow_update_budget');
+
+        this.#shadow_update_budget = v;
+    }
+
+    get shadow_update_budget() {
+        return this.#shadow_update_budget;
+    }
+
     feature_bloom_enabled = true;
     feature_automatic_exposure_enabled = true;
 
@@ -1803,6 +1824,8 @@ export class Renderer {
         // Which point-light shadow generator to use this frame; a flip triggers a rebuild of
         // existing point maps inside process_lights (run via view_ctx.update above/below).
         sm.use_tetrahedron_point_shadows = this.feature_tetrahedron_point_shadows;
+        // How many views the refresh scheduler may spend on this scene this frame.
+        sm.update_budget = this.#shadow_update_budget;
 
         const taa = this.#taa;
 

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAyMI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA0FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CAuNnB;IAkSD,gBAkBC;;CACJ;qCA9pCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA0NnB;IAkXD,gBAkBC;;CACJ;qCA1vCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js

@@ -145,13 +145,20 @@ export class GPUMeshSkinningContext {
      * {@link GPUAnimationManager#get_skin_matrix_offset}, and the
      * entity is its own meshes-table row, `entity + 1`.
      *
+     * `source_record` and `clone_record` are the pool's records for the two batches; the two
+     * offsets are copies of theirs, re-read whenever either record announces a move
+     * (COMPACTION_PLAN_2026_09_16 §5), and `unfollow` is how the binding stops listening.
+     *
      * @type {{
      *     skin_id: number,
      *     entity: number,
+     *     source_record: object,
+     *     clone_record: object,
      *     source_meshlet_metadata_offset: number,
      *     clone_meshlet_metadata_offset: number,
      *     meshlet_count: number,
      *     clone_geometry_index: number,
+     *     unfollow: function(): void,
      * }[]}
      */
     #bindings = [];
@@ -528,6 +535,8 @@ export class GPUMeshSkinningContext {
     #drop_binding_at(index) {
         const binding = this.#bindings[index];
 
+        binding.unfollow();
+
         this.#total_meshlet_count -= binding.meshlet_count;
 
         const offsets = this.#prev_position_offsets_cpu;
@@ -720,7 +729,10 @@ export class GPUMeshSkinningContext {
 
         if (this.#bindings_dirty) {
             // A binding's row is its entity's, and an entity's row never moves — so the records
-            // are written when the list changes and at no other time.
+            // are written when the list changes and at no other time. Its pool rows do move,
+            // and the pool says so; the binding list is dirty for that too.
+            this.#refresh_bindings_from_records();
+
             this.#upload_bindings();
 
             // None of these reads anything outside the binding list, so a scene edit that left
@@ -943,10 +955,15 @@ export class GPUMeshSkinningContext {
         const meshlet_count = clone_metadata.meshlets.meshlet_count;
         const clone_meshlet_metadata_offset = clone_metadata.meshlets.metadata.offset;
 
+        const source_record = source_metadata.meshlets;
+        const clone_record = clone_metadata.meshlets;
+
         const binding = {
             skin_id,
             entity,
-            source_meshlet_metadata_offset: source_metadata.meshlets.metadata.offset,
+            source_record,
+            clone_record,
+            source_meshlet_metadata_offset: source_record.metadata.offset,
             clone_meshlet_metadata_offset,
             meshlet_count,
             clone_geometry_index: clone_metadata.index,
@@ -956,6 +973,30 @@ export class GPUMeshSkinningContext {
             // slice back — filled in below, once the source's vertex counts have been walked
             prev_position_vertex_offset: 0,
             prev_position_vertex_count: 0,
+            unfollow: undefined,
+        };
+
+        // The pool moves batches — on a rebuild, and per frame once it sweeps — and announces
+        // a move through the record. What this binding uploaded names the old rows; mark the
+        // list and let `update` re-read both records and re-key the table before the pass. The
+        // listener compares first: a move of the data alone changes nothing a binding holds.
+        const follow = () => {
+            if (
+                binding.source_meshlet_metadata_offset !== source_record.metadata.offset
+                || binding.clone_meshlet_metadata_offset !== clone_record.metadata.offset
+            ) {
+                this.#bindings_dirty = true;
+            }
+        };
+
+        source_record.changed.add(follow);
+        clone_record.changed.add(follow);
+
+        // A source is shared by every clone of it and outlives any one binding, so a listener
+        // that outlived its binding would re-key rows that belong to a later clone by then.
+        binding.unfollow = () => {
+            source_record.changed.remove(follow);
+            clone_record.changed.remove(follow);
         };
 
         this.#bindings.push(binding);
@@ -994,18 +1035,69 @@ export class GPUMeshSkinningContext {
 
         this.#ensure_prev_position_offsets_capacity(clone_meshlet_metadata_offset + meshlet_count);
 
-        // Phase 2: per-meshlet offsets. Convert (vertex slot)
-        // to u32-word offset (× 3) since the side-buffer stores
-        // 3 × f32 per vertex back-to-back.
+        // Phase 2: per-meshlet offsets, into the rows the clone holds now
+        this.#write_prev_position_rows(binding);
+    }
+
+    /**
+     * One binding's entries in the prev-position table: for each of the clone's rows, the word
+     * offset of that meshlet's vertices in the side buffer — the binding's slice, walked in the
+     * source's vertex counts. (vertex slot) becomes a u32 word offset (× 3) because the side
+     * buffer stores 3 × f32 per vertex back-to-back.
+     *
+     * @param {object} binding
+     */
+    #write_prev_position_rows(binding) {
+        const view = new DataView(binding.source_record.metadata_buffer_original);
+
+        const first_row = binding.clone_meshlet_metadata_offset;
+        const base_vertex_offset = binding.prev_position_vertex_offset;
+
         let cumulative_vertex_offset = 0;
-        for (let i = 0; i < meshlet_count; i++) {
+
+        for (let i = 0; i < binding.meshlet_count; i++) {
             const vc = view.getUint32(i * MESHLET_STRIDE_BYTES + MESHLET_VERTEX_COUNT_BYTE_OFFSET, true);
-            const meshlet_word_offset = (base_vertex_offset + cumulative_vertex_offset) * 3;
-            this.#prev_position_offsets_cpu[clone_meshlet_metadata_offset + i] = meshlet_word_offset;
+
+            this.#prev_position_offsets_cpu[first_row + i] = (base_vertex_offset + cumulative_vertex_offset) * 3;
+
             cumulative_vertex_offset += vc;
         }
     }
 
+    /**
+     * Re-read every binding's pool rows from its records and re-key the prev-position table
+     * from the whole list.
+     *
+     * The whole list rather than the moved binding, because a rebuild of the pool fires
+     * `changed` in insertion order and one binding's new rows can be another's old ones: a
+     * per-binding "clear my old rows, write my new ones" would clear rows a binding before it
+     * had just written. Every row is INVALID first, then every binding writes its own; the
+     * prev-position *slices* themselves are keyed by word offset and do not move. The table is
+     * re-uploaded wholesale by the caller either way.
+     */
+    #refresh_bindings_from_records() {
+        const bindings = this.#bindings;
+
+        let required = 0;
+
+        for (const binding of bindings) {
+            binding.source_meshlet_metadata_offset = binding.source_record.metadata.offset;
+            binding.clone_meshlet_metadata_offset = binding.clone_record.metadata.offset;
+
+            required = Math.max(required, binding.clone_meshlet_metadata_offset + binding.meshlet_count);
+        }
+
+        if (required > 0) {
+            this.#ensure_prev_position_offsets_capacity(required);
+        }
+
+        this.#prev_position_offsets_cpu.fill(PREV_POSITION_OFFSET_INVALID);
+
+        for (const binding of bindings) {
+            this.#write_prev_position_rows(binding);
+        }
+    }
+
     /**
      * Grow {@link #prev_positions_buffer} to fit at least
      * `required_vertices` vertices. Doubles from

package/src/shade/renderer/extension/RENDER_EXTENSION_DESIGN.md

@@ -18,12 +18,23 @@ is the recorder invents a distinction that does not exist and outlaws the specul
 §5.1 is the argument; the bar it sets — a check may only fire on something that cannot be true —
 also took out a provenance check in §3.4.
 
+**Revised 2026-09-16: `after` / `before` are gone, replaced by `relative_order`.** They were
+built as specified, shipped, and then did the thing §1.4 rejected integer offsets to avoid — from
+the other direction. A constraint over classes is an import: `DebugDrawSystem`, which draws
+developer gizmos and knows nothing about anything, had to import `FogOfWarExtension` in order to
+say "on top". That is a generic extension acquiring a dependency on a game-specific one, at module
+scope, to express a fact about itself. `relative_order` is a number that defaults to 0 and names
+nothing: lower records first, negative pulls forward, positive pushes back. It is **less precise**
+and that is the trade — it cannot say "immediately after that one", and there is no cycle to detect
+because there is no graph. §1.4, §3.1, §3.6, §5, §7, §8 and §11 are updated; §3.6's ambiguity check
+was never built and is unaffected.
+
 ---
 
 ## 0. Summary
 
-An extension is a **named object with declarations** — a phase, ordering constraints, the optional
-frame products it needs — and one method that records into the frame's graph. Everything it exchanges
+An extension is a **named object with declarations** — a phase, where in that phase it sits, the
+optional frame products it needs — and one method that records into the frame's graph. Everything it exchanges
 with the frame goes through **typed per-frame records** holding frame-graph handles: it reads a
 handle out of a record and writes a replacement back. There is no return value and no privileged
 resource.
@@ -174,6 +185,13 @@ Not borrowed, deliberately:
   enum. It is the same defect as registration order with an extra step: unreadable, unstable under
   insertion, and it makes every ordering question a numerology question. Replaced by explicit
   `after` / `before` constraints over extension classes (§3.6).
+
+  > *Reversed, 2026-09-16.* Constraints over classes were built and are gone; §3.6 is now an offset
+  > within the phase. What this entry got right is that an offset is imprecise. What it missed is
+  > that it is imprecise *and names nothing*, where a constraint is precise and is an import — and
+  > an import is how a debug overlay ends up depending on the fog of war. The enum-offset objection
+  > also does not carry over: URP's `int` is an offset into a 17-value event enum, where a phase
+  > here is one of six coarse points and the offset orders only what shares it.
 - **`SetGlobalTexture` / global shader state.** An implicit channel between passes that the graph
   cannot see. Records are the channel.
 - **`AddUnsafePass`.** URP needs a legacy `CommandBuffer` escape hatch. There is no legacy to carry
@@ -191,7 +209,8 @@ Not borrowed, deliberately:
 ```js
 export class RenderExtension {
     /**
-     * Stable identity. Used in ordering diagnostics, error decoration and `describe()`.
+     * Stable identity. Used in error decoration and `describe()`, and the tie-break within one
+     * `relative_order`.
      * @type {string}
      */
     name = "";
@@ -200,12 +219,11 @@ export class RenderExtension {
     phase = FramePhase.AfterTransparency;
 
     /**
-     * Extension classes this one records after / before. Constructors, not instances — an
-     * extension does not need a reference to another system's object to state an order.
-     * @type {Function[]}
+     * Where in the phase this records. Lower first; any finite number, negative to pull forward.
+     * It names no other extension, which is the point.
+     * @type {number}
      */
-    after = [];
-    before = [];
+    relative_order = 0;
 
     /**
      * Optional frame products this extension reads. A bitmask of {@link FrameProduct}.
@@ -435,16 +453,22 @@ extension can do), `AfterShadows` (shadow rendering is per-light and interior to
 
 ### 3.6 Ordering
 
-Within a phase, order is the topological order of the `after` / `before` edges. Cycles throw at
-registration, naming the cycle. Both directions exist because an extension that must precede one it
-cannot edit is exactly the case an extension mechanism is for.
+Within a phase, order is `relative_order` ascending. It defaults to 0, takes any finite number, and
+says nothing about any other extension: an extension states where it belongs from what it *does* — a
+fog conceals, so it is late; a debug overlay must not be concealed, so it is later still.
 
-Unconstrained pairs are broken by `name`, ascending. Stable and reproducible; deliberately *not*
-registration order, so that adding an `await` to a system's startup cannot change the picture.
+Ties are broken by `name`, ascending. Stable and reproducible; deliberately *not* registration
+order, so that adding an `await` to a system's startup cannot change the picture.
+
+**This is coarse on purpose.** It cannot express "immediately after that one", and an effect that
+genuinely needs one particular extension's result has a real dependency rather than a positional
+one — it should read a record that extension published, which the graph then orders and keeps alive
+(§4). Because there are no edges there is no cycle: an order always resolves, and `add` refuses
+only a `relative_order` that is not a finite number.
 
 Name-order is stable, not correct. So the resolver also reports **ambiguity**: two extensions on one
-phase that publish the same field of the same record, with no ordering path between them, is an
-assert failure naming both and the field. Publication goes through our setters, so the frame knows
+phase that publish the same field of the same record at the same `relative_order` — so that only
+their names separate them — is an assert failure naming both and the field. Publication goes through our setters, so the frame knows
 who published what — no extra syntax on the author's side. This is the check that would have made
 somebody write down what the six-deep `AfterTransparency` chain is supposed to be.
 
@@ -545,14 +569,14 @@ here is zero in a shipped game and the checks may be as thorough as they like.
 | frame identity | read + publish | a handle retained across frames |
 | `is_valid_resource` | publish | publishing a superseded handle, attributed to the extension |
 | product declared by the recording extension | read | reading `velocity` because *someone else* required it |
-| ordering cycle | registration | `after`/`before` cycle, named |
-| publication ambiguity | end of phase | two extensions writing one field with no order between them |
+| `relative_order` finite | registration | an order that no comparator can answer, so the phase would sort by luck |
+| publication ambiguity | end of phase | two extensions writing one field at the same `relative_order` |
 
 Beneath all of them the graph runs its own `validate()` inside `compile()` (§4), which catches the
 data-order failures this layer cannot see.
 
 Every one of these fires on a **statement that cannot be true** — a superseded handle names one
-physical resource holding newer contents, a cycle has no order, an undeclared collision has no
+physical resource holding newer contents, `NaN` is not a position, an undeclared collision has no
 answer. None of them fires on an extension that is behaving correctly. That is the bar; §5.1 is
 what happens when a check is written without holding to it.
 
@@ -654,7 +678,7 @@ That is the entire surface.
 
 ```js
 // declaration
-class RenderExtension { name; phase; after; before; requires; record(frame); }
+class RenderExtension { name; phase; relative_order; requires; record(frame); }
 const FramePhase = { FrameStart, AfterGBuffer, AfterLighting, AfterTransparency, BeforePresent, Overlay };
 const FrameProduct = { Velocity, ColorCopy };
 
@@ -684,25 +708,26 @@ value becomes a publication.
 | consumer | phase | change beyond the mechanical |
 | --- | --- | --- |
 | `TerrainSystem` | `AfterGBuffer` | drops the registration-before-`await` comment; nothing else |
-| `DecalSystem` | `AfterGBuffer` | `after: [TerrainExtension]`, which is the constraint the comment in `TerrainSystem` was hand-enforcing; stops assigning through `context.gbuffer` |
+| `DecalSystem` | `AfterGBuffer` | `relative_order = 1`, which is what the comment in `TerrainSystem` was hand-enforcing; stops assigning through `context.gbuffer` |
 | `WaterSystem` | `AfterLighting` | publication instead of return; a candidate first consumer of `FrameProduct.ColorCopy` if refraction is wanted |
-| `FogOfWarSystem` | `AfterTransparency` | the grid update becomes a `FrameStart` extension publishing `FogOfWarVisibility`, and the composite reads it; declares `after` the four content extensions — **this is where §1.3a's shipped bug is fixed** |
-| `ParticleEmitterSystem` | `AfterTransparency` | — (now before the fog, by declaration) |
+| `FogOfWarSystem` | `AfterTransparency` | the grid update becomes a `FrameStart` extension publishing `FogOfWarVisibility`, and the composite reads it; `relative_order = 1` — **this is where §1.3a's shipped bug is fixed** |
+| `ParticleEmitterSystem` | `AfterTransparency` | — (at the default, so before the fog) |
 | `PathDisplaySystem` | `AfterTransparency` | — |
 | `HighlightSystem` | `AfterTransparency` | reads `ViewTextures.visibility_*`, unchanged in meaning |
-| `DebugDrawSystem` | `AfterTransparency` | `after: [FogOfWarExtension]` |
+| `DebugDrawSystem` | `AfterTransparency` | `relative_order = 2` |
 | `Trail3DSystem` | `AfterTransparency` | — |
 | `probeShadePassInjection` | all | the gate is rewritten and gains the two checks it is currently blind to: a G-buffer replacement, and an order flip |
 
-**The `AfterTransparency` chain is settled, not open.** Fog of war is last among the content
+**The `AfterTransparency` chain is settled, not open.** Fog of war is after the content
 extensions, because it conceals and therefore belongs over everything it is meant to conceal —
-particles, trails, path display and the selection highlight all draw before it and are all subject
-to it. Debug draw is the single deliberate exception, `after: [FogOfWarExtension]`: developer
+particles, trails, path display and the selection highlight all sit at the default order and are all
+subject to it. Debug draw is the single deliberate exception at `relative_order = 2`: developer
 geometry that the fog can hide is a debugging tool that stops working exactly where debugging is
 needed.
 
-That is six extensions and two declarations. Written down once, in the two files that care, instead
-of being a property of where an `await` sits.
+That is six extensions and two numbers. Written down once, in the two files that care, instead of
+being a property of where an `await` sits — and a seventh content extension is concealed by being
+added, without either of those two files changing.
 
 **The bug does not have to wait for the migration.** Today's ordering is registration order, so
 moving `FogOfWarSystem` below `Trail3DSystem` in `graphics_profile.js` fixes the picture now — at
@@ -743,7 +768,7 @@ a second declaration that can disagree with the code; observation cannot disagre
 Three steps, each independently green.
 
 - **A — the model.** Records, `FrameContext`, publication with all four checks, registry with
-  ordering, cycle detection and scoped recording. Port the nine systems and the viewer. Delete
+  ordering and scoped recording. Port the nine systems and the viewer. Delete
   `FramePassContext`, `FramePassRegistry` and `add_pass` / `remove_pass`. `FrameStart` and
   `PresentTarget` land here, because they are what the fog-of-war split and the `Overlay` rule need.
 - **B — diagnostics.** Ambiguity check and `describe()`. Nothing here waits on the engine; scoped
@@ -760,8 +785,9 @@ demand and it is separable on purpose.
 
 Device-free (`vitest`, from the moh root), black-box, real objects:
 
-- resolved order for a set of extensions with `after` / `before`; a cycle throws and names both;
-  unconstrained pairs resolve by name and the result does not change when registration order does.
+- resolved order for a set of extensions with a `relative_order`, positive and negative; ties
+  resolve by name and the result does not change when registration order does; an order that is not
+  a finite number is refused and leaves the registry as it was.
 - `get` of an absent record throws; `create` twice throws; `has` agrees with both.
 - publication of a superseded handle fails; publication into a frozen record fails; a handle from a
   previous frame fails. `FrameGraph` and a `SoftwareGPUDevice` are enough for all of these — no real
@@ -782,8 +808,9 @@ On a device, extending `probeShadePassInjection`:
 - **a G-buffer-replacing extension at `AfterGBuffer`** — writes a flat albedo, and the lit frame
   changes. The current gate has no such check, which is why the in/out G-buffer has never been
   exercised outside the decal system.
-- **an order flip** — two extensions publishing the colour, with the `after` edge reversed between
-  runs, producing different frames. This is the property the current mechanism cannot state at all.
+- **an order flip** — two extensions publishing the colour, with their `relative_order` swapped
+  between runs, producing different frames. This is the property the current mechanism cannot state
+  at all.
 - **the upscale boundary, at 60% dynamic resolution scale**: an extension at `AfterTransparency` and
   one at `BeforePresent`, each sizing its output from `frame.resolution`, both producing a full,
   uncropped frame. They must resolve to *different* sizes. The `BeforePresent` half of this fails on
@@ -815,6 +842,15 @@ every ordering claim is attributed to the resolver. The design would have been w
 > to reject; §3.6 is left owning the orders that are consistent and still wrong, which is exactly
 > the fog-over-particles case (§1.3a) and is the only kind of ordering bug the game actually had.
 
+**"A constraint over classes is an import, and you have just given the debug overlay a dependency on
+the fog of war."** Correct, and not caught here: it was caught by the shipped code, where
+`DebugDrawSystem` imports `FogOfWarExtension` at module scope for no reason but to say "on top".
+**Changed, 2026-09-16:** §3.6 is `relative_order`, a number that names nothing. The cost is real
+and is stated rather than argued away — an offset cannot express "immediately after that one", and
+§1.4 rejected offsets for being imprecise. The answer to the case that needs precision is that it is
+not a positional requirement at all: it is a data dependency, and a published record states it
+exactly and is enforced by the graph.
+
 **"`scene.color = handle` is untracked mutation — the same side channel you criticised
 `context.gbuffer` for being."** Half right. The criticism of `context.gbuffer` was that it was the
 *only* extra mutable thing, at *one* phase, invisible in the pass signature. **Changed:** publication

package/src/shade/renderer/extension/RenderExtension.d.ts

@@ -20,12 +20,12 @@
 export class RenderExtension {
     /**
      * Stable identity. It names the recording scope this extension's passes land in, and it is what
-     * an ordering diagnostic and a decorated error say.
+     * a decorated error says.
      *
-     * It is also the tie-break: two extensions on one phase with no ordering path between them
-     * record in ascending name order. That is reproducible rather than correct, and it is chosen
-     * over registration order precisely because adding an `await` to a system's startup must not
-     * change the picture.
+     * It is also the tie-break: two extensions on one phase with the same
+     * {@link relative_order} record in ascending name order. That is reproducible rather than
+     * correct, and it is chosen over registration order precisely because adding an `await` to a
+     * system's startup must not change the picture.
      *
      * @type {string}
      */
@@ -35,22 +35,19 @@ export class RenderExtension {
      */
     phase: FramePhase;
     /**
-     * Extension classes this one records after.
+     * Where in the phase this records. Lower goes first; any finite number, negative to pull
+     * forward, positive to push back.
      *
-     * Constructors, not instances — an extension does not need a reference to another system's
-     * object in order to state an order, and a class that nobody registered is simply not a
-     * constraint.
+     * It says nothing about any other extension, which is the point: an extension that must be late
+     * because of what it does — a fog that conceals, an overlay that must not be concealed — states
+     * that on its own, and needs no reference to, import of, or knowledge of whatever else happens
+     * to be on the phase. Coarse by design: it cannot express "immediately after that one", and an
+     * effect that genuinely needs that ordering is one whose input should be a published record
+     * instead.
      *
-     * @type {Function[]}
+     * @type {number}
      */
-    after: Function[];
-    /**
-     * Extension classes this one records before. Both directions exist because an extension that
-     * must precede one it cannot edit is exactly the case an extension mechanism is for.
-     *
-     * @type {Function[]}
-     */
-    before: Function[];
+    relative_order: number;
     /**
      * Record this extension's work into the frame. Called once per frame, when its phase comes
      * round, inside a recording scope named after it.

package/src/shade/renderer/extension/RenderExtension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderExtension.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/RenderExtension.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IACI;;;;;;;;;;OAUG;IACH,MAFU,MAAM,CAEN;IAEV;;OAEG;IACH,OAFU,UAAU,CAEiB;IAErC;;;;;;;;OAQG;IACH,OAFU,UAAU,CAET;IAEX;;;;;OAKG;IACH,QAFU,UAAU,CAER;IAEZ;;;;;;;;;OASG;IACH,cAFW,YAAY,QAGtB;CACJ;2BArEY,OAAO,mBAAmB,EAAE,YAAY;2BAH1B,iBAAiB"}
+{"version":3,"file":"RenderExtension.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/RenderExtension.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IACI;;;;;;;;;;OAUG;IACH,MAFU,MAAM,CAEN;IAEV;;OAEG;IACH,OAFU,UAAU,CAEiB;IAErC;;;;;;;;;;;;OAYG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;;;;OASG;IACH,cAFW,YAAY,QAGtB;CACJ;2BAjEY,OAAO,mBAAmB,EAAE,YAAY;2BAH1B,iBAAiB"}

package/src/shade/renderer/extension/RenderExtension.js

@@ -23,12 +23,12 @@ import { FramePhase } from "./FramePhase.js";
 export class RenderExtension {
     /**
      * Stable identity. It names the recording scope this extension's passes land in, and it is what
-     * an ordering diagnostic and a decorated error say.
+     * a decorated error says.
      *
-     * It is also the tie-break: two extensions on one phase with no ordering path between them
-     * record in ascending name order. That is reproducible rather than correct, and it is chosen
-     * over registration order precisely because adding an `await` to a system's startup must not
-     * change the picture.
+     * It is also the tie-break: two extensions on one phase with the same
+     * {@link relative_order} record in ascending name order. That is reproducible rather than
+     * correct, and it is chosen over registration order precisely because adding an `await` to a
+     * system's startup must not change the picture.
      *
      * @type {string}
      */
@@ -40,23 +40,19 @@ export class RenderExtension {
     phase = FramePhase.AfterTransparency;
 
     /**
-     * Extension classes this one records after.
+     * Where in the phase this records. Lower goes first; any finite number, negative to pull
+     * forward, positive to push back.
      *
-     * Constructors, not instances — an extension does not need a reference to another system's
-     * object in order to state an order, and a class that nobody registered is simply not a
-     * constraint.
+     * It says nothing about any other extension, which is the point: an extension that must be late
+     * because of what it does — a fog that conceals, an overlay that must not be concealed — states
+     * that on its own, and needs no reference to, import of, or knowledge of whatever else happens
+     * to be on the phase. Coarse by design: it cannot express "immediately after that one", and an
+     * effect that genuinely needs that ordering is one whose input should be a published record
+     * instead.
      *
-     * @type {Function[]}
+     * @type {number}
      */
-    after = [];
-
-    /**
-     * Extension classes this one records before. Both directions exist because an extension that
-     * must precede one it cannot edit is exactly the case an extension mechanism is for.
-     *
-     * @type {Function[]}
-     */
-    before = [];
+    relative_order = 0;
 
     /**
      * Record this extension's work into the frame. Called once per frame, when its phase comes

package/src/shade/renderer/extension/RenderExtensionRegistry.d.ts

@@ -2,9 +2,9 @@
  * The extensions an outside caller has put into a frame, kept per {@link FramePhase} in the order
  * their declarations resolve to.
  *
- * Device-free on purpose: this is the part of the mechanism with rules — ordering, cycles, removal,
- * what a recording scope is around — and keeping it out of the renderer means those rules can be
- * stated and tested without standing up a GPU.
+ * Device-free on purpose: this is the part of the mechanism with rules — ordering, removal, what a
+ * recording scope is around — and keeping it out of the renderer means those rules can be stated
+ * and tested without standing up a GPU.
  *
  * **The graph does not order extensions; this does.** `FrameGraph.execute` iterates its passes in
  * insertion order and does not sort, and `validate()` checks only that such an order is
@@ -15,8 +15,8 @@ export class RenderExtensionRegistry {
     /**
      * Register `extension` to record when its phase comes round.
      *
-     * The resolved order is computed here, so a cycle in the declarations fails at the registration
-     * that closed it, naming what it is made of. Registration order itself decides nothing.
+     * `relative_order` is read here, once. Moving an extension after it is registered means taking
+     * it out and putting it back.
      *
      * @param {RenderExtension} extension
      * @returns {RenderExtension} `extension`, so a caller can hold it for {@link remove} without

package/src/shade/renderer/extension/RenderExtensionRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderExtensionRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/RenderExtensionRegistry.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH;IA6BI;;;;;;;;;OASG;IACH,iDAiBC;IAED;;;;;;OAMG;IACH,oCAFa,OAAO,CAsBnB;IAED;;;OAGG;IACH,aAHW,UAAU,GACR,MAAM,CAOlB;IAED;;;;;;;;;OASG;IACH,+BA0CC;;CACJ;2BA3K4C,iBAAiB"}
+{"version":3,"file":"RenderExtensionRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/RenderExtensionRegistry.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH;IAqBI;;;;;;;;;OASG;IACH,iDAcC;IAED;;;;;;OAMG;IACH,oCAFa,OAAO,CAsBnB;IAED;;;OAGG;IACH,aAHW,UAAU,GACR,MAAM,CAOlB;IAED;;;;;;;;;OASG;IACH,+BA0CC;;CACJ;2BAhK4C,iBAAiB"}