@woosh/meep-engine 3.21.0 → 3.23.0

package/src/shade/playground/vgeo_viewer/select_cut.js

@@ -19,6 +19,13 @@ import { VGEO_SAME_PAGE } from "../../renderer/geometry/virtual/format/cluster/V
  * records carries the exact byte range that would refine it. That is what makes streaming safe in
  * any arrival order, and it is why this file's most interesting number is `clamped`.
  *
+ * "Not here" is `VGeoContainerReader.is_selectable`, not `is_resident`, and the difference is the
+ * one thing about this traversal that is not obvious: a group is refined into only once every page
+ * holding one of its *parents* is installed. Residency alone lets a group be entered through the
+ * parents that arrived while a coarse cluster still covers the one that did not, and then both are
+ * drawn over the same surface. §10 calls that out by name — "no holes **and no double-draw**, in any
+ * arrival order" — and the second half is the one that fails silently.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -125,6 +132,19 @@ export class VGeoCut {
      */
     clamped = 0;
 
+    /**
+     * Of those, the ones whose child group's page is **here** and merely not selectable yet, because
+     * a page holding one of that group's other parents is not.
+     *
+     * They carry no want: there is nothing to fetch from a cluster that already has the bytes it
+     * points at. What unblocks them is elsewhere in the same cut — the cluster clamped directly
+     * against the missing page — so this number is not a second streaming frontier, it is how much
+     * of the coarseness on screen is the ancestor rule holding a group back rather than bandwidth.
+     *
+     * @type {number}
+     */
+    clamped_on_activation = 0;
+
     /**
      * Which clusters those were, keyed `page · 65536 + cluster`. What the panel counts, a display
      * can paint — so the regions still waiting on bytes are visible as regions.
@@ -336,22 +356,33 @@ export function vgeo_select_cut(reader, view) {
                 continue;
             }
 
-            if (child_ref === VGEO_SAME_PAGE) {
-                push(stack, queued, page_index, page.child_group[id]);
-                continue;
-            }
-
-            if (child_ref >= page.child_page_index.length) {
+            if (child_ref !== VGEO_SAME_PAGE && child_ref >= page.child_page_index.length) {
                 cut.broken_child_refs++;
 
                 select(cut, page, id);
                 continue;
             }
 
-            const child_page = page.child_page_index[child_ref];
+            const child_page = child_ref === VGEO_SAME_PAGE
+                ? page_index
+                : page.child_page_index[child_ref];
 
-            if (reader.is_resident(child_page)) {
-                push(stack, queued, child_page, page.child_group[id]);
+            const child_group = page.child_group[id];
+
+            /*
+             *Selectable*, not resident — §10, and the difference is the whole of this file's
+             correctness. A group's parents are made by one simplification step but grouped for the
+             next one separately, so they can end up in different pages; refining into a group
+             because its own page arrived, while a page holding one of its other parents has not,
+             draws it underneath the coarse cluster still standing in for that parent. Both cover the
+             same surface and the depth buffer picks between them at random. `is_selectable` is the
+             counter that says the group's entire ancestor cone is here.
+
+             `SAME_PAGE` is asked the same question. Being in this page settles where the bytes are
+             and nothing about where the group's other parents live.
+             */
+            if (reader.is_selectable(child_page, child_group)) {
+                push(stack, queued, child_page, child_group);
                 continue;
             }
 
@@ -365,6 +396,19 @@ export function vgeo_select_cut(reader, view) {
 
             select(cut, page, id);
 
+            if (reader.is_resident(child_page)) {
+                /*
+                 §10: a want naming a page that is already installed is an activation recheck, never
+                 a fetch. There is nothing to ask for *here* — what this group is waiting on is a
+                 page holding one of its other parents, and the format stores parent counts rather
+                 than parent references precisely so that nobody has to name it. Another cluster in
+                 this same traversal is clamped directly against that page and wants it, because
+                 monotonicity puts every ancestor of a cluster projecting above τ above τ as well.
+                 */
+                cut.clamped_on_activation++;
+                continue;
+            }
+
             want(wants, page, child_ref, child_page, self_px);
         }
     }

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

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} SamplerDescriptor
+ */
 export class GPUSamplerManager {
     constructor(device: any);
     /**
@@ -14,4 +17,5 @@ export class GPUSamplerManager {
     obtain(descriptor: SamplerDescriptor): GPUSampler;
     #private;
 }
+export type SamplerDescriptor = import("../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor;
 //# sourceMappingURL=GPUSamplerManager.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUSamplerManager.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GPUSamplerManager.js"],"names":[],"mappings":"AAGA;IAWI,yBAEC;IAED;;;;OAIG;IACH,kDAEC;IAED;;;;OAIG;IACH,kDAKC;;CAEJ"}
+{"version":3,"file":"GPUSamplerManager.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GPUSamplerManager.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;IAWI,yBAEC;IAED;;;;OAIG;IACH,mBAHW,iBAAiB,cAK3B;IAED;;;;OAIG;IACH,mBAHW,iBAAiB,cAQ3B;;CAEJ;gCAvCY,OAAO,4CAA4C,EAAE,iBAAiB"}

package/src/shade/renderer/GPUSamplerManager.js

@@ -1,6 +1,10 @@
 import { assert } from "../../core/assert.js";
 import { Cache } from "../../core/cache/Cache.js";
 
+/**
+ * @typedef {import("../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} SamplerDescriptor
+ */
+
 export class GPUSamplerManager {
 
     #cache = new Cache({

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

@@ -118,6 +118,8 @@ export class GraphicsContext {
     readonly isGraphicsContext: boolean;
     #private;
 }
+export type BufferDescriptor = import("../descriptor/buffer/BufferDescriptor.js").BufferDescriptor;
+export type PipelineDescriptorBase = import("../descriptor/pipeline/PipelineDescriptorBase.js").PipelineDescriptorBase;
 export type BinaryBuffer = import("../../core/binary/BinaryBuffer.js").BinaryBuffer;
 import { GPUGeometryManager } from "./geometry/GPUGeometryManager.js";
 import { GPUMaterialManager } from "./material/GPUMaterialManager.js";

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":"AA4BA;IAoJI,yBA8BC;IAjLD;;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;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAkCD;;;;;;;;OAQG;IACH,gGALW,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,mDAFa,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAcC;IAED,4BAEC;IAED,eAmBC;IAED,gBAcC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;2BAtUY,OAAO,mCAAmC,EAAE,YAAY;mCAZlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAXzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAchD,6BAA6B;sCACtB,4CAA4C;iCAbjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAErC,uCAAuC;oCAO7C,kCAAkC;iCARtB,8BAA8B"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAiCA;IAoJI,yBA8BC;IAjLD;;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;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAkCD;;;;;;;;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,+BAcC;IAED,4BAEC;IAED,eAmBC;IAED,gBAcC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BA5UY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAXzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAchD,6BAA6B;sCACtB,4CAA4C;iCAbjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAErC,uCAAuC;oCAO7C,kCAAkC;iCARtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -20,6 +20,11 @@ import { GPUTextureAllocator } from "./texture/GPUTextureAllocator.js";
 import { TextureManager } from "./texture/TextureManager.js";
 import { VirtualTextureManager } from "./texture/virtual/VirtualTextureManager.js";
 
+/**
+ * @typedef {import("../descriptor/buffer/BufferDescriptor.js").BufferDescriptor} BufferDescriptor
+ * @typedef {import("../descriptor/pipeline/PipelineDescriptorBase.js").PipelineDescriptorBase} PipelineDescriptorBase
+ */
+
 
 /**
  * @typedef {import("../../core/binary/BinaryBuffer.js").BinaryBuffer} BinaryBuffer

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

@@ -357,11 +357,16 @@ export class Renderer {
     get nss(): NSS;
     /**
      *
-     * @param {GPUCanvasContext} [context] Optional, if not provided - one will be created.
-     * @param {GPUDevice} [device] Optional, if not provided - one will be created.
-     * @param {number} [pixelRatio] Optiona, if not provided - will be taken from browser context
+     * @param {Object} [options]
+     * @param {GPUCanvasContext} [options.context] Optional, if not provided - one will be created.
+     * @param {GPUDevice} [options.device] Optional, if not provided - one will be created.
+     * @param {number} [options.pixelRatio] Optional, if not provided - will be taken from browser context
      */
-    initialize({ context, device, pixelRatio, }?: GPUCanvasContext): Promise<void>;
+    initialize({ context, device, pixelRatio, }?: {
+        context?: GPUCanvasContext;
+        device?: GPUDevice;
+        pixelRatio?: number;
+    }): Promise<void>;
     /**
      * Cleanup
      */
@@ -406,6 +411,11 @@ export class Renderer {
     render_to_target(camera: PerspectiveCamera, scene: Scene, time_delta_seconds: number, target: GPUTextureContext): boolean;
     #private;
 }
+export type GPUProfileSession = import("../device/timing/profile/GPUProfileSession.js").GPUProfileSession;
+export type PerspectiveCamera = import("./camera/PerspectiveCamera.js").PerspectiveCamera;
+export type RenderExtension = import("./extension/RenderExtension.js").RenderExtension;
+export type GPUSceneContext = import("./scene/GPUSceneContext.js").GPUSceneContext;
+export type Scene = import("./scene/Scene.js").Scene;
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";

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

@@ -67,7 +67,6 @@ import { RasterizationJob } from "./rasterize/RasterizationJob.js";
 import { graph_rasterize_scene } from "./rasterize/standard/graph_rasterize_scene.js";
 import { ReSTIRDI } from "./restir/di/ReSTIRDI.js";
 import { GPUParticleSystem } from "./particles/GPUParticleSystem.js";
-import { ParticleRenderMode } from "./particles/ParticleRenderMode.js";
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
@@ -83,6 +82,14 @@ import { RenderTarget } from "./texture/RenderTarget.js";
 import { View } from "./view/View.js";
 import { ViewManager } from "./view/ViewManager.js";
 
+/**
+ * @typedef {import("../device/timing/profile/GPUProfileSession.js").GPUProfileSession} GPUProfileSession
+ * @typedef {import("./camera/PerspectiveCamera.js").PerspectiveCamera} PerspectiveCamera
+ * @typedef {import("./extension/RenderExtension.js").RenderExtension} RenderExtension
+ * @typedef {import("./scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ * @typedef {import("./scene/Scene.js").Scene} Scene
+ */
+
 const METRICS = new MetricCollection();
 METRICS.create({ name: 'frame_time' });
 
@@ -814,27 +821,27 @@ export class Renderer {
                                  resolution,
                              }) {
 
-        const mode = this.indirect_lighting_mode;
-        // Prefer fusion where supported to avoid intermediate diffuse/specular
-        // targets and repeated G-buffer reads. This is a local graph policy.
-        const prefer_fused = true;
-        const lpv = scene_ctx.light_probe_volume;
-        let diffuse_pass;
-        let specular_pass;
-        let ssr_inputs;
+        const mode = this.indirect_lighting_mode;
+        // Prefer fusion where supported to avoid intermediate diffuse/specular
+        // targets and repeated G-buffer reads. This is a local graph policy.
+        const prefer_fused = true;
+        const lpv = scene_ctx.light_probe_volume;
+        let diffuse_pass;
+        let specular_pass;
+        let ssr_inputs;
 
         // Each mode owns its diffuse/specular pair and any fused implementation.
         // SSR overrides specular below using the same explicitly selected mode.
         switch (mode) {
-            case ShadeIndirectLightingMode.IBL:
-                ssr_inputs = { input_environment: gr_texture_environment };
-                diffuse_pass = {
-                    shader: shader_diffuse_IBL,
-                    inputs: {
-                        tBentNormals: bent_normals,
-                        tGBufferAlbedo: gr_texture_material_albedo_ao,
-                        tEnvironment: gr_texture_environment,
-                    },
+            case ShadeIndirectLightingMode.IBL:
+                ssr_inputs = { input_environment: gr_texture_environment };
+                diffuse_pass = {
+                    shader: shader_diffuse_IBL,
+                    inputs: {
+                        tBentNormals: bent_normals,
+                        tGBufferAlbedo: gr_texture_material_albedo_ao,
+                        tEnvironment: gr_texture_environment,
+                    },
                 };
                 specular_pass = {
                     shader: shader_specular_IBL,
@@ -850,8 +857,8 @@ export class Renderer {
                 break;
 
             case ShadeIndirectLightingMode.Brick4:
-                // SSR needs its own specular resolve and denoising passes.
-                if (prefer_fused && !this.feature_ssr_enabled) {
+                // SSR needs its own specular resolve and denoising passes.
+                if (prefer_fused && !this.feature_ssr_enabled) {
                     [current_color_out] = graph_image_pass({
                         graph,
                         shader: shader_brick4_indirect_lighting,
@@ -872,20 +879,20 @@ export class Renderer {
                             tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
                         },
                     });
-                    return current_color_out;
-                }
-                ssr_inputs = { brick4: scene_ctx.volumetric_light_map };
-                diffuse_pass = {
-                    shader: shader_brick4_diffuse,
-                    inputs: {
-                        tDepth: gr_texture_depth_current,
-                        tBentNormals: bent_normals,
-                        tAlbedoAO: gr_texture_material_albedo_ao,
-                        tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
-                        camera: gr_buffer_camera_current,
-                        view: view_ctx.uniform_buffer.buffer,
-                        brick4: scene_ctx.volumetric_light_map.buffer,
-                    },
+                    return current_color_out;
+                }
+                ssr_inputs = { brick4: scene_ctx.volumetric_light_map };
+                diffuse_pass = {
+                    shader: shader_brick4_diffuse,
+                    inputs: {
+                        tDepth: gr_texture_depth_current,
+                        tBentNormals: bent_normals,
+                        tAlbedoAO: gr_texture_material_albedo_ao,
+                        tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                        camera: gr_buffer_camera_current,
+                        view: view_ctx.uniform_buffer.buffer,
+                        brick4: scene_ctx.volumetric_light_map.buffer,
+                    },
                 };
                 specular_pass = {
                     shader: shader_brick4_specular,
@@ -901,22 +908,22 @@ export class Renderer {
                 };
                 break;
 
-            case ShadeIndirectLightingMode.LPV:
-                ssr_inputs = { lpv, input_environment: gr_texture_environment };
-                diffuse_pass = {
-                    shader: shader_diffuse_LPV,
-                    inputs: {
-                        camera: gr_buffer_camera_current,
-                        tDepth: gr_texture_depth_current,
-                        tBentNormals: bent_normals,
-                        tGBufferAlbedo: gr_texture_material_albedo_ao,
-                        lpv_atlas_radiance: lpv.atlas.texture_radiance,
-                        lpv_atlas_depth: lpv.atlas.texture_depth,
-                        lpv_lookup: lpv.buffer_mesh_bvh,
-                        lpv_metadata: lpv.buffer_metadata,
-                        lpv_mesh: lpv.buffer_mesh,
-                        lpv_probes: lpv.buffer_probes,
-                    },
+            case ShadeIndirectLightingMode.LPV:
+                ssr_inputs = { lpv, input_environment: gr_texture_environment };
+                diffuse_pass = {
+                    shader: shader_diffuse_LPV,
+                    inputs: {
+                        camera: gr_buffer_camera_current,
+                        tDepth: gr_texture_depth_current,
+                        tBentNormals: bent_normals,
+                        tGBufferAlbedo: gr_texture_material_albedo_ao,
+                        lpv_atlas_radiance: lpv.atlas.texture_radiance,
+                        lpv_atlas_depth: lpv.atlas.texture_depth,
+                        lpv_lookup: lpv.buffer_mesh_bvh,
+                        lpv_metadata: lpv.buffer_metadata,
+                        lpv_mesh: lpv.buffer_mesh,
+                        lpv_probes: lpv.buffer_probes,
+                    },
                 };
                 // Without SSR, LPV uses environment-map specular.
                 specular_pass = {
@@ -938,9 +945,9 @@ export class Renderer {
 
         let indirect_specular;
         if (this.feature_ssr_enabled) {
-            const ssr = this.#postprocess.ssr.graph_pass({
-                graph,
-                ...ssr_inputs,
+            const ssr = this.#postprocess.ssr.graph_pass({
+                graph,
+                ...ssr_inputs,
                 view_ctx,
                 jitter: view_ctx.jitter,
                 input_depth_previous: gr_texture_depth_previous,
@@ -954,7 +961,7 @@ export class Renderer {
                 input_occlusion: gr_occlusion_clip,
                 camera_current: gr_buffer_camera_current,
                 camera_previous: gr_buffer_camera_previous,
-                indirect_lighting_mode: mode,
+                indirect_lighting_mode: mode,
                 resolution,
             });
 
@@ -1183,9 +1190,10 @@ export class Renderer {
 
     /**
      *
-     * @param {GPUCanvasContext} [context] Optional, if not provided - one will be created.
-     * @param {GPUDevice} [device] Optional, if not provided - one will be created.
-     * @param {number} [pixelRatio] Optiona, if not provided - will be taken from browser context
+     * @param {Object} [options]
+     * @param {GPUCanvasContext} [options.context] Optional, if not provided - one will be created.
+     * @param {GPUDevice} [options.device] Optional, if not provided - one will be created.
+     * @param {number} [options.pixelRatio] Optional, if not provided - will be taken from browser context
      */
     async initialize({
                          context,
@@ -2297,22 +2305,17 @@ export class Renderer {
         if (this.feature_particles_enabled) {
             const particles = this.particles(scene_ctx);
 
-            // The simulation runs here; the drawing is the side channels', below. AVBOIT mode is
-            // what says so: the colour comes back untouched, no sort is recorded, and none of the
-            // sort's scratch is ever allocated, because the accumulators it would feed are sums.
+            // The simulation runs here and touches no colour target; the drawing is the side
+            // channels', below, inside the AVBOIT transparency pipeline.
             //
             // Not conditional on {@link transparency_mode}. MBOIT has no particle channel, so under
-            // it the particles simulate and are not drawn — the same as before this was a mode, and
-            // the `ShadeTransparencyMode` docs say why the legacy path stays as it is. Giving MBOIT
-            // `BILLBOARD` here would draw them, but over the transparency composite rather than
-            // through it, which is a worse picture than none.
-            current_color_out = particles.execute({
+            // it the particles simulate and are not drawn, and the `ShadeTransparencyMode` docs say
+            // why the legacy path stays as it is.
+            particles.execute({
                 graph,
                 camera: gr_buffer_camera_current,
                 scene_database: gr_scene_database_for_velocity,
-                color: current_color_out,
                 dt: time_delta_seconds,
-                mode: ParticleRenderMode.AVBOIT,
             });
 
             particle_side_channels.push(particles);

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

@@ -1,3 +1,9 @@
+/**
+ * @typedef {import("../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js").ResourceDescriptor} ResourceDescriptor
+ * @typedef {import("../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
+ * @typedef {import("../device/graph/GraphicsExecutionContext.js").GraphicsExecutionContext} GraphicsExecutionContext
+ * @typedef {import("./GraphicsContext.js").GraphicsContext} GraphicsContext
+ */
 export class ResourceManager {
     /**
      *
@@ -29,4 +35,8 @@ export class ResourceManager {
     release<T>(resource: T): void;
     destroy(): void;
 }
+export type ResourceDescriptor = import("../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js").ResourceDescriptor;
+export type ShadeGPUCommandContext = import("../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
+export type GraphicsExecutionContext = import("../device/graph/GraphicsExecutionContext.js").GraphicsExecutionContext;
+export type GraphicsContext = import("./GraphicsContext.js").GraphicsContext;
 //# sourceMappingURL=ResourceManager.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ResourceManager.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/ResourceManager.js"],"names":[],"mappings":"AAEA;IAiBI;;;;OAIG;IACH,wEAGC;IAvBD;;OAEG;IACH,8BAAG;IAEH;;OAEG;IACH,gCAAO;IAEP;;OAEG;IACH,0BAAQ;IAaR;;;OAGG;IACH,yCASC;IAED;;;OAGG;IACH,8BAUC;IAED,gBAEC;CACJ"}
+{"version":3,"file":"ResourceManager.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/ResourceManager.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH;IAiBI;;;;OAIG;IACH,sBAHW,eAAe,WACf,sBAAsB,EAKhC;IAvBD;;OAEG;IACH,KAFU,wBAAwB,CAE/B;IAEH;;OAEG;IACH,SAFU,sBAAsB,CAEzB;IAEP;;OAEG;IACH,UAFU,eAAe,CAEjB;IAaR;;;OAGG;IACH,gBAFW,kBAAkB,OAW5B;IAED;;;OAGG;IACH,8BAUC;IAED,gBAEC;CACJ;iCApEY,OAAO,yEAAyE,EAAE,kBAAkB;qCACpG,OAAO,qCAAqC,EAAE,sBAAsB;uCACpE,OAAO,6CAA6C,EAAE,wBAAwB;8BAC9E,OAAO,sBAAsB,EAAE,eAAe"}

package/src/shade/renderer/ResourceManager.js

@@ -1,5 +1,12 @@
 import { GPUTextureContext } from "./texture/GPUTextureContext.js";
 
+/**
+ * @typedef {import("../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js").ResourceDescriptor} ResourceDescriptor
+ * @typedef {import("../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
+ * @typedef {import("../device/graph/GraphicsExecutionContext.js").GraphicsExecutionContext} GraphicsExecutionContext
+ * @typedef {import("./GraphicsContext.js").GraphicsContext} GraphicsContext
+ */
+
 export class ResourceManager {
 
     /**

package/src/shade/renderer/animation/GPUAnimationManager.d.ts

@@ -65,9 +65,12 @@ export class GPUAnimationManager {
      */
     get prev_skin_matrices_buffer(): any;
     /**
-     * Number of matrices currently in use (= sum of `joint_count` over
-     * registered skins). Independent of buffer capacity, which is at
-     * least this big.
+     * Matrices the buffer has to address: the high-water mark, which covers every registered
+     * skin plus any range sitting on the free list between the ones still in use. Independent
+     * of buffer capacity, which is at least this big.
+     *
+     * Not a count of live joints — a skin that unregisters leaves its range addressable for
+     * the next skin of its size, so this falls only when nothing has been registered yet.
      *
      * @returns {number}
      */
@@ -387,8 +390,8 @@ export class GPUAnimationManager {
      * may be in use by other clips. Removing them would need
      * reference-counting the manager doesn't carry.
      *
-     * Safe to call repeatedly on the same id (subsequent calls are
-     * no-ops once the row is gone).
+     * Safe to call repeatedly on the same id: the second call finds the row unoccupied and
+     * returns without walking anything.
      *
      * @param {number} clip_id
      */
@@ -400,13 +403,12 @@ export class GPUAnimationManager {
      * context doesn't try to read the now-freed skin's matrix
      * offset on its next upload).
      *
-     * The skin's reserved matrix range stays allocated — compaction
-     * isn't supported in the MVP. Re-registering after an
-     * `unregister_skin` therefore costs new matrix slots; long-
-     * running spawn/despawn loops accumulate wasted slots.
+     * The skin's matrix range goes back on the free list, for the next skin with the same
+     * joint count to take as-is. A spawn/despawn loop over a fixed cast therefore costs
+     * what the cast costs, not what the loop has run.
      *
-     * Tolerates the skin still being pending. Safe to call
-     * repeatedly on the same id.
+     * Tolerates the skin still being pending. Safe to call repeatedly on the same id: the
+     * second call finds the row unoccupied and gives no range back twice.
      *
      * @param {number} skin_id
      */
@@ -491,5 +493,10 @@ export class GPUAnimationManager {
     destroy(): void;
     #private;
 }
+export type AnimationCurve = import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve;
+export type ShadeGPUCommandContext = import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
+export type GPUSceneContext = import("../scene/GPUSceneContext.js").GPUSceneContext;
+export type ShadeAnimationClip = import("./ShadeAnimationClip.js").ShadeAnimationClip;
+export type Skin = import("./Skin.js").Skin;
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 //# sourceMappingURL=GPUAnimationManager.d.ts.map

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IA6OI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eARW;QACV,IAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAc,CAAC,EAAE,MAAM,CAAC;QACxB,QAAc,EAAE,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC1E,GACS,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eALW;QACV,MAAY,EAAE,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC,CAAC;KAC1E,GACS,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA0FlB;IAyLD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAsElB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAoChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA6ChB;IAqHD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,kDAFW,MAAM,QAmChB;IA8FD,gBAYC;;CACJ;4BAn6D2B,gCAAgC"}
+{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"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"}