@woosh/meep-engine 3.33.0 → 3.34.0

package/src/shade/renderer/geometry/virtual/runtime/cut/vgeo_cut_feedback_layout.d.ts

@@ -1,36 +1,64 @@
 /**
  * Where each region of the feedback buffer starts, for one frame's worth of cutting.
  *
- * One function rather than two agreeing conventions: the pass that creates the buffer and the
- * params block that tells the kernel where to write both come from here, and so does anything that
- * reads it back. A layout computed twice is a layout that drifts, and the way it drifts is a want
- * list written over the touch bits, which reads as wants that never resolve.
- *
- * **Header, touch bits, want records — and the whole of it is read back.** Two regions used to sit
- * between the header and the lists and neither was the CPU's business: a stamp word per page row
- * and a stamp word per lookup word, cleared with the transient every frame and mapped back with
- * it. At the playground's 4,096 slots that was 344 KB a frame across the bus for 33 KB of lists,
- * and the lookup-sized half of it grew with every registered geometry rather than with anything
- * seen. The touch stamps are the touch bits now — one bit per row, which is both the dedup and
- * the record — and the want stamps live in a persistent, frame-tagged buffer the pool owns and
- * nothing reads back (RUNTIME_PLAN_2026_09_14 §2.2, §2.3).
+ * One function rather than two agreeing conventions: the pass that clears the buffer and the params
+ * block that tells the kernel where to write both come from here, and so does anything that reads it
+ * back. A layout computed twice is a layout that drifts, and the way it drifts is a want list written
+ * over the touch bits, which reads as wants that never resolve.
+ *
+ * **A header per view slot, the touch bits, then a want slice per slot — and the whole of it is read
+ * back.** Every view that cuts in a frame takes a slot (SHADOW_PLAN_2026_09_28 §2.4): its own counters
+ * and its own want list, so that a shadow view recording first cannot fill the list the main view
+ * records into later, and a reading can say which view needed more wavefronts. The touch bits stay
+ * one set — a page any view draws from is a page in use. With one slot this is the layout the buffer
+ * always had: the header at word 0, the touch bits after it, the wants after those.
+ *
+ * `want_capacity` is what one frame may ask for across every view, divided evenly among the slots,
+ * so the readback does not grow with the number of views.
  *
  * @param {Object} options
  * @param {number} options.page_row_capacity one touch bit per page-table row
- * @param {number} options.want_capacity records
- * @returns {{touch_bits_base: number, touch_word_count: number, want_base: number,
- *     word_count: number}}
+ * @param {number} options.want_capacity records, across every slot
+ * @param {number} options.slot_count views the frame is laid out for
+ * @returns {{slot_count: number, touch_bits_base: number, touch_word_count: number, want_base: number,
+ *     slot_want_capacity: number, clear_word_count: number, word_count: number}}
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_cut_feedback_layout({ page_row_capacity, want_capacity }: {
+export function vgeo_cut_feedback_layout({ page_row_capacity, want_capacity, slot_count }: {
     page_row_capacity: number;
     want_capacity: number;
+    slot_count: number;
 }): {
+    slot_count: number;
     touch_bits_base: number;
     touch_word_count: number;
     want_base: number;
+    slot_want_capacity: number;
+    clear_word_count: number;
     word_count: number;
 };
+/**
+ * Word offset of a slot's want counter.
+ *
+ * @param {number} slot
+ * @returns {number}
+ */
+export function vgeo_feedback_slot_want_count(slot: number): number;
+/**
+ * Word offset of a slot's first counter, {@link VGEO_CUT_STAT} indexing from it.
+ *
+ * @param {number} slot
+ * @returns {number}
+ */
+export function vgeo_feedback_slot_stats(slot: number): number;
+/**
+ * Word offset of a slot's first want record.
+ *
+ * @param {ReturnType<vgeo_cut_feedback_layout>} layout
+ * @param {number} slot
+ * @returns {number}
+ */
+export function vgeo_feedback_slot_wants(layout: ReturnType<typeof vgeo_cut_feedback_layout>, slot: number): number;
 //# sourceMappingURL=vgeo_cut_feedback_layout.d.ts.map

package/src/shade/renderer/geometry/virtual/runtime/cut/vgeo_cut_feedback_layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_cut_feedback_layout.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/vgeo_cut_feedback_layout.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAR2B,iBAAiB,EAAjC,MAAM;IACU,aAAa,EAA7B,MAAM;IACJ;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAClF,UAAgB,EAAE,MAAM,CAAA;CAAC,CAmBzB"}
+{"version":3,"file":"vgeo_cut_feedback_layout.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/vgeo_cut_feedback_layout.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAT2B,iBAAiB,EAAjC,MAAM;IACU,aAAa,EAA7B,MAAM;IACU,UAAU,EAA1B,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IACtG,kBAAwB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA4B/E;AAED;;;;;GAKG;AACH,oDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,+CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,iDAJW,2CAAoC,QACpC,MAAM,GACJ,MAAM,CAIlB"}

package/src/shade/renderer/geometry/virtual/runtime/cut/vgeo_cut_feedback_layout.js

@@ -5,41 +5,83 @@ import { VGEO_WANT_WORDS } from "../layout/VGEO_WANT_WORDS.js";
 /**
  * Where each region of the feedback buffer starts, for one frame's worth of cutting.
  *
- * One function rather than two agreeing conventions: the pass that creates the buffer and the
- * params block that tells the kernel where to write both come from here, and so does anything that
- * reads it back. A layout computed twice is a layout that drifts, and the way it drifts is a want
- * list written over the touch bits, which reads as wants that never resolve.
- *
- * **Header, touch bits, want records — and the whole of it is read back.** Two regions used to sit
- * between the header and the lists and neither was the CPU's business: a stamp word per page row
- * and a stamp word per lookup word, cleared with the transient every frame and mapped back with
- * it. At the playground's 4,096 slots that was 344 KB a frame across the bus for 33 KB of lists,
- * and the lookup-sized half of it grew with every registered geometry rather than with anything
- * seen. The touch stamps are the touch bits now — one bit per row, which is both the dedup and
- * the record — and the want stamps live in a persistent, frame-tagged buffer the pool owns and
- * nothing reads back (RUNTIME_PLAN_2026_09_14 §2.2, §2.3).
+ * One function rather than two agreeing conventions: the pass that clears the buffer and the params
+ * block that tells the kernel where to write both come from here, and so does anything that reads it
+ * back. A layout computed twice is a layout that drifts, and the way it drifts is a want list written
+ * over the touch bits, which reads as wants that never resolve.
+ *
+ * **A header per view slot, the touch bits, then a want slice per slot — and the whole of it is read
+ * back.** Every view that cuts in a frame takes a slot (SHADOW_PLAN_2026_09_28 §2.4): its own counters
+ * and its own want list, so that a shadow view recording first cannot fill the list the main view
+ * records into later, and a reading can say which view needed more wavefronts. The touch bits stay
+ * one set — a page any view draws from is a page in use. With one slot this is the layout the buffer
+ * always had: the header at word 0, the touch bits after it, the wants after those.
+ *
+ * `want_capacity` is what one frame may ask for across every view, divided evenly among the slots,
+ * so the readback does not grow with the number of views.
  *
  * @param {Object} options
  * @param {number} options.page_row_capacity one touch bit per page-table row
- * @param {number} options.want_capacity records
- * @returns {{touch_bits_base: number, touch_word_count: number, want_base: number,
- *     word_count: number}}
+ * @param {number} options.want_capacity records, across every slot
+ * @param {number} options.slot_count views the frame is laid out for
+ * @returns {{slot_count: number, touch_bits_base: number, touch_word_count: number, want_base: number,
+ *     slot_want_capacity: number, clear_word_count: number, word_count: number}}
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_cut_feedback_layout({ page_row_capacity, want_capacity }) {
+export function vgeo_cut_feedback_layout({ page_row_capacity, want_capacity, slot_count }) {
     assert.isNonNegativeInteger(page_row_capacity, 'page_row_capacity');
     assert.isNonNegativeInteger(want_capacity, 'want_capacity');
+    assert.isNonNegativeInteger(slot_count, 'slot_count');
+    assert.greaterThan(slot_count, 0, 'slot_count');
 
-    const touch_bits_base = VGEO_FEEDBACK_OFFSET.HEADER_WORDS;
+    const touch_bits_base = slot_count * VGEO_FEEDBACK_OFFSET.HEADER_WORDS;
     const touch_word_count = Math.max(1, Math.ceil(page_row_capacity / 32));
     const want_base = touch_bits_base + touch_word_count;
 
+    const slot_want_capacity = Math.floor(want_capacity / slot_count);
+
     return {
+        slot_count,
         touch_bits_base,
         touch_word_count,
         want_base,
-        word_count: want_base + want_capacity * VGEO_WANT_WORDS,
+        slot_want_capacity,
+        // the counters and the touch bits start every frame at zero; a want record is only ever read
+        // below its slot's count, so the lists need no clearing
+        clear_word_count: want_base,
+        word_count: want_base + slot_count * slot_want_capacity * VGEO_WANT_WORDS,
     };
 }
+
+/**
+ * Word offset of a slot's want counter.
+ *
+ * @param {number} slot
+ * @returns {number}
+ */
+export function vgeo_feedback_slot_want_count(slot) {
+    return slot * VGEO_FEEDBACK_OFFSET.HEADER_WORDS + VGEO_FEEDBACK_OFFSET.WANT_COUNT;
+}
+
+/**
+ * Word offset of a slot's first counter, {@link VGEO_CUT_STAT} indexing from it.
+ *
+ * @param {number} slot
+ * @returns {number}
+ */
+export function vgeo_feedback_slot_stats(slot) {
+    return slot * VGEO_FEEDBACK_OFFSET.HEADER_WORDS + VGEO_FEEDBACK_OFFSET.STATS;
+}
+
+/**
+ * Word offset of a slot's first want record.
+ *
+ * @param {ReturnType<vgeo_cut_feedback_layout>} layout
+ * @param {number} slot
+ * @returns {number}
+ */
+export function vgeo_feedback_slot_wants(layout, slot) {
+    return layout.want_base + slot * layout.slot_want_capacity * VGEO_WANT_WORDS;
+}

package/src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_if_enabled.d.ts

@@ -7,18 +7,15 @@
  * at all, because a wavefront is sixty-odd dispatches whose only output would be zero.
  *
  * The frame check is the second half of that. A runtime exists from the moment somebody enables it,
- * but its feedback buffer exists only between `begin_frame` and `end_frame`; a path that runs
- * outside a frame — a shadow view built before the main pass opens one, say — skips rather than
- * writing into a resource that is not there.
+ * but a frame is open only while the renderer is rendering one; a path that runs outside it — a
+ * bake, a preview drawn outside `Renderer.render` — skips rather than cutting against feedback no
+ * reading will ever collect.
  *
- * **And the graph check is the third.** `GPUSceneShadowmapContext` records through
- * `graph_rasterize_scene_fast_raw`, which carries this seam, on a `FrameGraph` of its own — so a
- * cube or tetra face inside an open frame would run a whole cut, at the *main camera's* projection
- * scale, writing into a resource handle that belongs to another graph. Design §4 pins one cut per
- * view and RUNTIME_PLAN §9 scopes shadow cuts out of v1; a graph that is not the one the frame was
- * opened on is therefore not a graph this seam belongs in (REVIEW_LEDGER M13). When shadow views do
- * get cuts, they get their own `begin_frame` and their own τ, and this check is what makes that a
- * change rather than a discovery.
+ * **Any graph of the frame may cut.** It used to be only the graph the frame was opened on, because
+ * the feedback buffer was a transient of that graph and a shadow map records into a `FrameGraph` of
+ * its own — so shadow views skipped, and virtual geometry cast no shadows (REVIEW_LEDGER M13,
+ * SHADOW_PLAN_2026_09_28). The buffer is the runtime's now and each graph imports it, so a shadow
+ * view is a view like any other: its own projection, its own threshold, its own slot.
  *
  * @param {Object} options
  * @param {FrameGraph} options.graph

package/src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_if_enabled.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_vgeo_expand_if_enabled.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAV+B,KAAK;IACT,YAAY,EAA5B,MAAM;IACU,eAAe,EAA/B,MAAM;IACkB,IAAI;IACC,MAAM;IACjC,MAAM,CAyBlB"}
+{"version":3,"file":"graph_vgeo_expand_if_enabled.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAV+B,KAAK;IACT,YAAY,EAA5B,MAAM;IACU,eAAe,EAA/B,MAAM;IACkB,IAAI;IACC,MAAM;IACjC,MAAM,CAqBlB"}

package/src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js

@@ -9,18 +9,15 @@ import { graph_vgeo_expand_instances_to_meshlets } from "./graph_vgeo_expand_ins
  * at all, because a wavefront is sixty-odd dispatches whose only output would be zero.
  *
  * The frame check is the second half of that. A runtime exists from the moment somebody enables it,
- * but its feedback buffer exists only between `begin_frame` and `end_frame`; a path that runs
- * outside a frame — a shadow view built before the main pass opens one, say — skips rather than
- * writing into a resource that is not there.
+ * but a frame is open only while the renderer is rendering one; a path that runs outside it — a
+ * bake, a preview drawn outside `Renderer.render` — skips rather than cutting against feedback no
+ * reading will ever collect.
  *
- * **And the graph check is the third.** `GPUSceneShadowmapContext` records through
- * `graph_rasterize_scene_fast_raw`, which carries this seam, on a `FrameGraph` of its own — so a
- * cube or tetra face inside an open frame would run a whole cut, at the *main camera's* projection
- * scale, writing into a resource handle that belongs to another graph. Design §4 pins one cut per
- * view and RUNTIME_PLAN §9 scopes shadow cuts out of v1; a graph that is not the one the frame was
- * opened on is therefore not a graph this seam belongs in (REVIEW_LEDGER M13). When shadow views do
- * get cuts, they get their own `begin_frame` and their own τ, and this check is what makes that a
- * change rather than a discovery.
+ * **Any graph of the frame may cut.** It used to be only the graph the frame was opened on, because
+ * the feedback buffer was a transient of that graph and a shadow map records into a `FrameGraph` of
+ * its own — so shadow views skipped, and virtual geometry cast no shadows (REVIEW_LEDGER M13,
+ * SHADOW_PLAN_2026_09_28). The buffer is the runtime's now and each graph imports it, so a shadow
+ * view is a view like any other: its own projection, its own threshold, its own slot.
  *
  * @param {Object} options
  * @param {FrameGraph} options.graph
@@ -42,11 +39,7 @@ export function graph_vgeo_expand_if_enabled({
                                              }) {
     const runtime = view?.scene?.virtual_geometry;
 
-    if (runtime === undefined || runtime.feedback === -1) {
-        return output_meshlets;
-    }
-
-    if (runtime.frame_graph !== graph) {
+    if (runtime === undefined || !runtime.frame_open) {
         return output_meshlets;
     }
 

package/src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_vgeo_expand_instances_to_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAX+B,KAAK;IACT,YAAY,EAA5B,MAAM;IACU,eAAe,EAA/B,MAAM;IACkB,IAAI;IACO,OAAO;IACb,MAAM;IACjC,MAAM,CA6SlB"}
+{"version":3,"file":"graph_vgeo_expand_instances_to_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAX+B,KAAK;IACT,YAAY,EAA5B,MAAM;IACU,eAAe,EAA/B,MAAM;IACkB,IAAI;IACO,OAAO;IACb,MAAM;IACjC,MAAM,CA4TlB"}

package/src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.js

@@ -68,12 +68,13 @@ export function graph_vgeo_expand_instances_to_meshlets({
     assert.isNonNegativeInteger(input_meshes, 'input_meshes');
     assert.isNonNegativeInteger(output_meshlets, 'output_meshlets');
     assert.defined(runtime, 'runtime');
-    assert.notEqual(runtime.feedback, -1, 'runtime.feedback — begin_frame must have run');
+    assert.equal(runtime.frame_open, true, 'runtime.frame_open — begin_frame must have run');
 
     const scene = view.scene;
     const pool = runtime.pool;
 
-    graph.push_scope("virtual geometry cut");
+    // which view, in a capture: a frame cuts once per site of every view, and the scopes were identical
+    graph.push_scope(`virtual geometry cut (${view.label ?? 'a view'})`);
 
     const instance_capacity = Math.max(1, limits.get_limit(RasterizationCollectionType.Meshes));
 
@@ -98,9 +99,11 @@ export function graph_vgeo_expand_instances_to_meshlets({
     */
     const view_cut = view.virtual_geometry_cut;
 
+    // off the matrix the view draws with, so a cascade's orthographic camera is a projection too
     view_cut.set_projection({
-        screen_height: Math.max(1, view.resolution[1]),
-        fov_y: view.camera.camera.fov,
+        width: Math.max(1, view.resolution[0]),
+        height: Math.max(1, view.resolution[1]),
+        projection_matrix: view.camera.camera.projection_matrix,
     });
 
     /*
@@ -117,7 +120,19 @@ export function graph_vgeo_expand_instances_to_meshlets({
     */
     view_cut.clear_frontier();
 
-    view_cut.write_params({ runtime });
+    /*
+     This view's slot in the frame's feedback — its own counters, its own want slice and its own stamp
+     tag, taken the first time it cuts in the frame and the same at every site after.
+    */
+    const slot = runtime.slot_of(view_cut);
+
+    view_cut.write_params({ runtime, slot });
+
+    // the frame's feedback buffer, as this graph knows it: imported on first use, cleared by the first
+    const feedback_in = runtime.feedback_in(graph);
+
+    // and this view's own wavefront bound, raised from its own readings
+    const max_iterations = view_cut.iterations_under(runtime);
 
     // ----- collect: which of these instances are virtual, and where is the camera in each one -----
 
@@ -161,7 +176,7 @@ export function graph_vgeo_expand_instances_to_meshlets({
     ));
 
     // the first writer of the frame's counters, so the version chain starts here
-    collect_data.feedback = collect_pass.write(runtime.feedback);
+    collect_data.feedback = collect_pass.write(feedback_in);
 
     /*
      The scan turns each instance's claim width into the first bit of its slice. It is the same
@@ -241,7 +256,7 @@ export function graph_vgeo_expand_instances_to_meshlets({
 
     // ----- the wavefront -----
 
-    for (let iteration = 0; iteration < runtime.max_iterations; iteration++) {
+    for (let iteration = 0; iteration < max_iterations; iteration++) {
         const prepare_data = {};
 
         const prepare_pass = graph.add(
@@ -342,12 +357,12 @@ export function graph_vgeo_expand_instances_to_meshlets({
     feedback = tail_data.feedback = tail_pass.write(feedback);
 
     /*
-     Every expansion of this frame writes into one feedback buffer, so the next one has to start
-     from the version this one produced rather than from the version `begin_frame` created — and so
+     Every expansion of this graph writes into one feedback buffer, so the next one has to start
+     from the version this one produced rather than from the version the import created — and so
      does the readback. The graph catches the alternative outright, which is the best kind of
      invariant to have.
      */
-    runtime.publish_feedback(feedback);
+    runtime.publish_feedback(graph, feedback);
 
     graph.pop_scope();
 

package/src/shade/renderer/geometry/virtual/runtime/layout/VGEO_FEEDBACK_OFFSET.js

@@ -1,12 +1,14 @@
 import { VGEO_CUT_STAT_COUNT } from "./VGEO_CUT_STAT_COUNT.js";
 
 /**
- * Word offsets in the feedback buffer — the one thing the cut hands back to the CPU, and the only
- * place in the runtime where a GPU pass and a host frame meet.
+ * Word offsets within one view slot's header in the feedback buffer — the one thing the cut hands
+ * back to the CPU, and the only place in the runtime where a GPU pass and a host frame meet.
  *
- * Header first, then the touch bits, then the want records; see `vgeo_cut_feedback_layout` for the
- * two that move. Design §6: the wants loop tolerates its transport — multi-frame `mapAsync`
- * latency, a small in-flight cap, and frames where feedback is skipped entirely.
+ * A header per slot, then the touch bits, then a want slice per slot; see
+ * `vgeo_cut_feedback_layout` for where each starts. Slot 0's header is at word 0, so a frame of one
+ * view is laid out exactly as the buffer always was. Design §6: the wants loop tolerates its
+ * transport — multi-frame `mapAsync` latency, a small in-flight cap, and frames where feedback is
+ * skipped entirely.
  *
  * There is no touch count any more. A touch is one bit per page row (RUNTIME_PLAN_2026_09_14
  * §2.2), so the list it used to count, and the capacity that list could overflow, are gone.
@@ -21,9 +23,9 @@ export const VGEO_FEEDBACK_OFFSET = {
      */
     STATS: 1,
     /**
-     * Where the touch bits begin. The want records follow them, and their base travels in the
-     * params block because a graph resource's size is a host-side decision and the kernel must not
-     * assume one.
+     * Words in one slot's header. The touch bits begin after the last slot's, and the want records
+     * after those; their bases travel in the params block because a buffer's layout is a host-side
+     * decision and the kernel must not assume one.
      */
     HEADER_WORDS: 1 + VGEO_CUT_STAT_COUNT,
 };

package/src/shade/renderer/geometry/virtual/runtime/layout/VGEO_INSTANCE_OFFSET.d.ts

@@ -7,5 +7,6 @@ export namespace VGEO_INSTANCE_OFFSET {
     let LOOKUP_WORD_OFFSET: number;
     let CLAIM_BASE: number;
     let ORDINAL_CAPACITY: number;
+    let DISTANCE_WEIGHT: number;
 }
 //# sourceMappingURL=VGEO_INSTANCE_OFFSET.d.ts.map

package/src/shade/renderer/geometry/virtual/runtime/layout/VGEO_INSTANCE_OFFSET.js

@@ -19,14 +19,19 @@ export const VGEO_INSTANCE_OFFSET = {
      */
     EYE: 0,
     /**
-     * `screen_height / (2 * tan(fov_y / 2))`, times the scale correction below.
+     * The view's pixels per unit — see `VGeoViewCut.set_projection` — times the scale correction
+     * below.
      *
-     * Error and distance are both object-space, so a **uniform** instance scale cancels out of
-     * `r_e * k / d` exactly and needs no term at all. A non-uniform one does not cancel, and the
-     * correction is the ratio of the transform's singular values — σ_max / σ_min, not the ratio of
-     * its column lengths, which a shear leaves at 1 while stretching space without bound
-     * (REVIEW_LEDGER M4). It over-refines rather than under-refines, and it is exactly 1 for every
-     * instance that is not stretched.
+     * **Perspective:** error and distance are both object-space, so a **uniform** instance scale
+     * cancels out of `r_e * k / d` exactly and needs no term at all. A non-uniform one does not
+     * cancel, and the correction is the ratio of the transform's singular values — σ_max / σ_min,
+     * not the ratio of its column lengths, which a shear leaves at 1 while stretching space without
+     * bound (REVIEW_LEDGER M4). It over-refines rather than under-refines, and it is exactly 1 for
+     * every instance that is not stretched.
+     *
+     * **Orthographic:** there is no distance for a scale to cancel against, so an object-space error
+     * becomes world units by the instance's scale and the correction is σ_max alone. Both are
+     * `σ_max / (w · σ_min + 1 − w)` with `w` the {@link DISTANCE_WEIGHT} below.
      */
     PROJECTION_K: 3,
     /**
@@ -51,4 +56,11 @@ export const VGEO_INSTANCE_OFFSET = {
      * How many bits that slice runs to.
      */
     ORDINAL_CAPACITY: 28,
+    /**
+     * How much distance divides the projected error: 1 for a perspective view, 0 for an orthographic
+     * one. `vg_project` divides by `w · d + (1 − w)`, so a parallel projection's error is `r_e · k`
+     * wherever the cluster is, and the camera-inside-the-sphere rule — which has no meaning without
+     * an eye — cannot fire.
+     */
+    DISTANCE_WEIGHT: 29,
 };

package/src/shade/renderer/geometry/virtual/runtime/make_vgeo_page_worker.d.ts

@@ -2,9 +2,11 @@
  * Spawn one page-fetch worker.
  *
  * The `new Worker(new URL(..., import.meta.url), { type: "module" })` form is what the consumer's
- * bundler detects and what vite serves as-is, and it lives in a module no spec imports, because
+ * bundler detects and what vite serves as-is, and it lives in a module of its own because
  * `import.meta` is a parse error under a CommonJS transform — the same arrangement
- * `makeClothWorker` keeps for the same reason.
+ * `makeClothWorker` keeps for the same reason. Specs do import it, through `GPUSceneContext`: vitest
+ * parses it as ESM, and nothing is resolved until a worker is spawned, which
+ * `GPUSceneContext.destroy.spec.js` does against a stand-in global `Worker`.
  *
  * @returns {Worker}
  *

package/src/shade/renderer/geometry/virtual/runtime/make_vgeo_page_worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_vgeo_page_worker.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/make_vgeo_page_worker.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,yCALa,MAAM,CAOlB"}
+{"version":3,"file":"make_vgeo_page_worker.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/make_vgeo_page_worker.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,yCALa,MAAM,CAOlB"}

package/src/shade/renderer/geometry/virtual/runtime/make_vgeo_page_worker.js

@@ -2,9 +2,11 @@
  * Spawn one page-fetch worker.
  *
  * The `new Worker(new URL(..., import.meta.url), { type: "module" })` form is what the consumer's
- * bundler detects and what vite serves as-is, and it lives in a module no spec imports, because
+ * bundler detects and what vite serves as-is, and it lives in a module of its own because
  * `import.meta` is a parse error under a CommonJS transform — the same arrangement
- * `makeClothWorker` keeps for the same reason.
+ * `makeClothWorker` keeps for the same reason. Specs do import it, through `GPUSceneContext`: vitest
+ * parses it as ESM, and nothing is resolved until a worker is spawned, which
+ * `GPUSceneContext.destroy.spec.js` does against a stand-in global `Worker`.
  *
  * @returns {Worker}
  *

package/src/shade/renderer/global_illumination/brick4/Brick4LightMap.d.ts

@@ -11,6 +11,10 @@ export class Brick4LightMap {
      * @param {ArrayBuffer} data
      */
     upload(data: ArrayBuffer): void;
+    /**
+     * Release the map's buffer. Safe to call twice.
+     */
+    destroy(): void;
     #private;
 }
 //# sourceMappingURL=Brick4LightMap.d.ts.map

package/src/shade/renderer/global_illumination/brick4/Brick4LightMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Brick4LightMap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/brick4/Brick4LightMap.js"],"names":[],"mappings":"AAKA;IAsBI;;;OAGG;IACH,+BAUC;IA5BD,kBAEC;IAQD,4BAEC;IAkBD;;;OAGG;IACH,aAFW,WAAW,QAgDrB;;CAEJ"}
+{"version":3,"file":"Brick4LightMap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/brick4/Brick4LightMap.js"],"names":[],"mappings":"AAKA;IAsBI;;;OAGG;IACH,+BAUC;IA5BD,kBAEC;IAQD,4BAEC;IAkBD;;;OAGG;IACH,aAFW,WAAW,QAgDrB;IAED;;OAEG;IACH,gBAEC;;CAEJ"}

package/src/shade/renderer/global_illumination/brick4/Brick4LightMap.js

@@ -93,4 +93,11 @@ export class Brick4LightMap {
 
     }
 
+    /**
+     * Release the map's buffer. Safe to call twice.
+     */
+    destroy() {
+        this.#buffer.destroy();
+    }
+
 }

package/src/shade/renderer/global_illumination/lpv/GPULightProbeVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/GPULightProbeVolume.js"],"names":[],"mappings":"AAeA;;GAEG;AAGH;IAsFI;;;;OAIG;IACH,uCAFW,gBAAgB,EAmC1B;IArHD;;;OAGG;IACH,+DAEC;IAOD;;;OAGG;IACH,6BAEC;IAOD;;;OAGG;IACH,+BAEC;IAOD;;;OAGG;IACH,sCAEC;IAOD,iCAEC;IAoBD;;OAEG;IACH,OAFU,aAAa,CAEjB;IA4JN,oBAwDC;IAED,eAIC;IAED,eAMC;IAED,gBAKC;IAED,4BAMC;IAED;;OAEG;IACH,0BAsBC;IAED,wBAOC;;CACJ;+BA9WY,OAAO,uBAAuB,EAAE,gBAAgB;+BAV9B,gCAAgC;8BAIjC,sCAAsC"}
+{"version":3,"file":"GPULightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/GPULightProbeVolume.js"],"names":[],"mappings":"AAeA;;GAEG;AAGH;IAsFI;;;;OAIG;IACH,uCAFW,gBAAgB,EAmC1B;IArHD;;;OAGG;IACH,+DAEC;IAOD;;;OAGG;IACH,6BAEC;IAOD;;;OAGG;IACH,+BAEC;IAOD;;;OAGG;IACH,sCAEC;IAOD,iCAEC;IAoBD;;OAEG;IACH,OAFU,aAAa,CAEjB;IA4JN,oBAwDC;IAED,eAIC;IAED,eAMC;IAED,gBAMC;IAED,4BAMC;IAED;;OAEG;IACH,0BAsBC;IAED,wBAOC;;CACJ;+BA/WY,OAAO,uBAAuB,EAAE,gBAAgB;+BAV9B,gCAAgC;8BAIjC,sCAAsC"}

package/src/shade/renderer/global_illumination/lpv/GPULightProbeVolume.js

@@ -334,6 +334,7 @@ export class GPULightProbeVolume {
         this.#buffer_mesh.destroy();
         this.#buffer_probes.destroy();
         this.#buffer_metadata.destroy();
+        this.#buffer_mesh_bvh.destroy();
         this.atlas.destroy();
     }
 

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#252@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#250@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/material/GPUMaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AAyNA;IAiFI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAmD3B;IApID;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAsBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAoLD;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAiMnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAWC;IAED;;;;;;;;;OASG;IACH,kBAFW,qBAAqB,QAM/B;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAiChC;;CAEJ;6BA51BY,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCApBzE,yBAAyB;mCAjBG,8CAA8C"}
+{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AAyNA;IAiFI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAmD3B;IApID;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAsBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAoLD;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAiMnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;;;OASG;IACH,kBAFW,qBAAqB,QAM/B;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAiChC;;CAEJ;6BA91BY,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCApBzE,yBAAyB;mCAjBG,8CAA8C"}

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -724,6 +724,8 @@ export class GPUMaterialManager {
 
         this.#dynamic_contexts.length = 0;
 
+        this.#metadata_table.destroy();
+
         this.#list_version++;
         this.#version++;
     }

package/src/shade/renderer/particles/DESIGN.md

@@ -523,12 +523,7 @@ alpha scaled before premultiplication.
 
 Additive vs. alpha is never a pipeline switch: the shader emits premultiplied RGB with alpha 0
 (additive) or alpha a (normal), so one setup covers both and the choice stays per particle and
-GPU-driven. Under AVBOIT that choice picks which accumulators the fragment writes; in the blended
-pipeline `shaders/shader_particle_render.js` builds it is one blend state,
-`(one, one-minus-src-alpha)` on both channels. That pipeline is not this system's — it is what
-`GPUParticularRenderer` draws `particular`'s CPU-simulated particles with, over a draw list it sorts
-back to front on the CPU — but it shares this vertex stage, this atlas and flipbook math, and
-`particle_fade_color`, so a sprite looks the same whichever draws it.
+GPU-driven. Under AVBOIT that choice picks which accumulators the fragment writes.
 
 ### Drawing: an AVBOIT side channel
 
@@ -564,8 +559,8 @@ contribution at the three points where the meshlet buckets have just made theirs
    The whole decision is `chunk_particle_avboit_contribution`, and it is spec'd on the emulator.
 
 All three read the alive list and the draw args straight from `simulate`; the vertex stage is one
-chunk (`chunk_particle_billboard_vertex`), shared by the splat, the draw and the blended pipeline
-`particular` uses. `GPUParticleSystem` implements the three methods; `Renderer.feature_particles_enabled`
+chunk (`chunk_particle_billboard_vertex`), shared by the splat and the draw. `GPUParticleSystem`
+implements the three methods; `Renderer.feature_particles_enabled`
 runs `execute` before the transparency pass and hands the system to the orchestrator. MBOIT is legacy
 and gets no particle path, so under it the particles simulate and are not drawn.
 
@@ -582,7 +577,7 @@ everything `chunk_particle_avboit_contribution` does after its premultiply
 ECS system over the pair `[ParticleEffect, Transform64]` — the component says what an entity emits,
 the transform says where — in exactly the shape `DecalSystem` and `MeshSystem` use for their own
 content. Construct it with `(graphicsEngine, scene, assetManager)` and add it to the EntityManager.
-It is opt-in and coexists with the legacy CPU `ParticleEmitterSystem`.
+It is opt-in.
 
 ```js
 entityManager.addSystem(new GPUParticleEmitterSystem(graphics, scene, assetManager));
@@ -719,7 +714,6 @@ src/shade/renderer/particles/
   shaders/shader_particle_emit.js            per-newborn INIT, sized by the scan
   shaders/shader_particle_simulate.js        per-particle UPDATE + compaction + orphan kill
   shaders/shader_particle_finalize.js        reset counters (+ budget) / build indirect args
-  shaders/shader_particle_render.js          blended billboard pipeline (GPUParticularRenderer's)
   shaders/chunk_particle_setup_context.js    VM builtins from the emitter's node, + the RNG seed
   shaders/chunk_particle_emitter_age.js      the tick pass's running age, off the emitter_state table
   shaders/chunk_particle_spawn_budget.js     take from the frame's spawn budget; both ticks spend it

package/src/shade/renderer/particles/ParticleConstants.d.ts

@@ -253,9 +253,7 @@ export const PARTICLE_SIM_PAD_SLOT: number;
  * Above all it is what the two passes that have to agree on a fragment's coverage agree on: the
  * AVBOIT draw, which weights the accumulators by it, and the AVBOIT splat, which records the
  * extinction the volume then hands to everything behind. A fade in one and not the other is a
- * surface that is invisible and still occludes. The blended billboard pipeline
- * (`shaders/shader_particle_render.js`) reads it too, so a particle fades over the same distance
- * whichever pipeline draws it.
+ * surface that is invisible and still occludes.
  *
  * @type {number}
  */