@woosh/meep-engine 3.30.0 → 3.32.0

package/src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_compute_indirect_pass.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH;IAP+B,KAAK;IACF,MAAM;IACb,QAAQ;IACR,OAAO,EAAvB,MAAM;IACa,KAAK;QAyDlC"}
+{"version":3,"file":"graph_compute_indirect_pass.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH;IAP+B,KAAK;IACF,MAAM;IACb,QAAQ;IACR,OAAO,EAAvB,MAAM;IACa,KAAK;QAyDlC"}

package/src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.js

@@ -5,6 +5,10 @@ import { graph_prepare_compute_resources } from "./graph_prepare_compute_resourc
 
 /**
  * Simplified way of running compute shaders
+ *
+ * The shader should not read `@builtin(num_workgroups)`: dispatched indirectly, that costs ~15 µs a
+ * dispatch on D3D12. See `renderer/gpu_primitive/indirect/NOTES.md`.
+ *
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {ComputeShader} options.shader

package/src/shade/renderer/shader/graph/graph_import_typed_buffer.d.ts

@@ -3,7 +3,8 @@
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {WebGPUType} options.type type of the buffer
- * @param {*} options.value actual value to store in the imported buffer
+ * @param {*} options.value actual value to store in the imported buffer. Give every field: one left
+ *        out is skipped, not zeroed, so it holds whatever bytes the upload memory held before
  * @param {string} [options.label] optional name for the new resource, if not specified will assume name of the type
  * @param {GPUBufferUsage|number} options.usage
  * @returns {number}

package/src/shade/renderer/shader/graph/graph_import_typed_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_import_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_import_typed_buffer.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IArB+B,KAAK;IACL,IAAI;IACb,KAAK;IACC,KAAK,GAAtB,MAAM;IACyB,KAAK,EAApC,iBAAe,MAAM;IACnB,MAAM,CAkFlB"}
+{"version":3,"file":"graph_import_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_import_typed_buffer.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAtB+B,KAAK;IACL,IAAI;IACb,KAAK;IAEC,KAAK,GAAtB,MAAM;IACyB,KAAK,EAApC,iBAAe,MAAM;IACnB,MAAM,CAqElB"}

package/src/shade/renderer/shader/graph/graph_import_typed_buffer.js

@@ -1,13 +1,13 @@
 import { assert } from "../../../../core/assert.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
-import { write_gpu_typed_buffer } from "../type/serde/write_gpu_typed_buffer.js";
 
 /**
  *
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {WebGPUType} options.type type of the buffer
- * @param {*} options.value actual value to store in the imported buffer
+ * @param {*} options.value actual value to store in the imported buffer. Give every field: one left
+ *        out is skipped, not zeroed, so it holds whatever bytes the upload memory held before
  * @param {string} [options.label] optional name for the new resource, if not specified will assume name of the type
  * @param {GPUBufferUsage|number} options.usage
  * @returns {number}
@@ -52,32 +52,19 @@ export function graph_import_typed_buffer({
     function execute(data, resources, context) {
         const gpu_buffer = resources.get(data.buffer);
 
-        const encoder = context.encoder;
-
-        // TODO this is pretty inefficient, figure out a way to skip needing 2 buffers
-        // [AG - 2025/09/13] - Using a transient buffer and a queue.writeBuffer resulted in garbage being written.
-        //                     No idea why currently, creating a new buffer works for now, but the underlying issue is not resolved
-
-        const _size = type.size;
-        const buffer = encoder.device.createBuffer({
-            label: "Import typed buffer/ temp buffer",
-            size: _size,
-            usage: GPUBufferUsage.COPY_SRC,
-            mappedAtCreation: true
-        });
-
-        const mapped = buffer.getMappedRange();
-
-        write_gpu_typed_buffer(value, type, mapped);
-        buffer.unmap();
-        // Copy is necessary to ensure a correct device timeline
-
-        encoder.copyBufferToBuffer(buffer, 0, gpu_buffer, 0, _size);
-
-        encoder.onFinished.addOne(() => {
-
-            buffer.destroy();
-        })
+        /*
+         Recorded in order, where this pass runs — never `queue.writeBuffer`.
+
+         The resource is a frame graph transient, and the pool hands a transient out again as soon
+         as its last user in the frame has run, so this buffer may have held another resource
+         earlier in the same submission, written by a pass recorded before this one. A queue write
+         lands ahead of the whole submission, that earlier pass's write executes after it, and the
+         reader gets the earlier pass's bytes. That is the garbage this import wrote in 2025, twice:
+         queue-writing the resource itself, then queue-writing a transient from the same pool and
+         copying from that. A mapped buffer created for every call hid it, at a create and a destroy
+         per import per frame.
+        */
+        context.encoder.writeValueBuffer(gpu_buffer, 0, type, value);
     }
 
     const pass = graph.add("import_typed_buffer", data, execute);

package/src/shade/renderer/shader/pass/RenderPassDescriptor.d.ts

@@ -2,6 +2,14 @@
  * {@link GPURenderPassDescriptor}
  */
 export class RenderPassDescriptor {
+    /**
+     * What the render pass is called. Unset, the pipeline's label names it, which is what a pass with
+     * one pipeline wants; a pass with a pipeline per material template has no one pipeline to take
+     * it from.
+     *
+     * @type {string|undefined}
+     */
+    label: string | undefined;
     /**
      * @type {RenderPipelineDescriptor}
      */

package/src/shade/renderer/shader/pass/RenderPassDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAG1E;;;;;;;;;;;OAWG;IACH;QAVyC,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACnB,MAAM;QACL,OAAO;QACR,WAAW;QACV,YAAY;QACb,WAAW;QACV,YAAY;gCAwE3C;IAED;;;;;;;;;;;OAWG;IACH;QAT2C,OAAO;QACT,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACtB,QAAQ;QACA,eAAe;QACpB,MAAM;QACL,OAAO;kCAqCtC;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACpB,OAAO;QACT,cAAc,GAA/B,MAAM;QACW,QAAQ;QACH,aAAa;aAgB7C;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DAxL0D,iDAAiD"}
+{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;;;;;OAMG;IACH,OAFU,MAAM,GAAC,SAAS,CAER;IAElB;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAG1E;;;;;;;;;;;OAWG;IACH;QAVyC,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACnB,MAAM;QACL,OAAO;QACR,WAAW;QACV,YAAY;QACb,WAAW;QACV,YAAY;gCAwE3C;IAED;;;;;;;;;;;OAWG;IACH;QAT2C,OAAO;QACT,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACtB,QAAQ;QACA,eAAe;QACpB,MAAM;QACL,OAAO;kCAuCtC;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACpB,OAAO;QACT,cAAc,GAA/B,MAAM;QACW,QAAQ;QACH,aAAa;aAgB7C;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DAnM0D,iDAAiD"}

package/src/shade/renderer/shader/pass/RenderPassDescriptor.js

@@ -1,193 +1,204 @@
-import { assert } from "../../../../core/assert.js";
-import { rp_rewrite_for_primitive_state } from "../../../device/pipeline/rp_rewrite_for_primitive_state.js";
-import { RenderPassDepthStencilAttachmentDescriptor } from "./RenderPassDepthStencilAttachmentDescriptor.js";
-
-/**
- * {@link GPURenderPassDescriptor}
- */
-export class RenderPassDescriptor {
-    /**
-     * @type {RenderPipelineDescriptor}
-     */
-    pipeline
-
-    /**
-     * @type {ShaderResourceSetDescriptor}
-     */
-    resources
-
-    /**
-     *
-     * @type {RenderPassColorAttachmentDescriptor[]}
-     */
-    colorAttachments = [];
-
-    /**
-     *
-     * @type {RenderPassDepthStencilAttachmentDescriptor}
-     */
-    depthStencilAttachment = new RenderPassDepthStencilAttachmentDescriptor();
-
-
-    /**
-     * @param {Object} options
-     * @param {GPUTextureContext[]} [options.colorTargets]
-     * @param {GPUTextureContext} [options.depthTarget]
-     * @param {GPULoadOp} [options.loadOp="clear"] Used for both color targets and depth target
-     * @param {GPUStoreOp} [options.storeOp="store"] Used for both color targets and depth target
-     * @param {GPULoadOp} [options.colorLoadOp] defaults to `loadOp`
-     * @param {GPUStoreOp} [options.colorStoreOp] defaults to `storeOp`
-     * @param {GPULoadOp} [options.depthLoadOp] defaults to `loadOp`
-     * @param {GPUStoreOp} [options.depthStoreOp] defaults to `storeOp`
-     * @returns {GPURenderPassDescriptor}
-     */
-    toGPU({
-              colorTargets = [],
-              depthTarget,
-              loadOp = "clear",
-              storeOp = "store",
-              colorLoadOp = loadOp,
-              colorStoreOp = storeOp,
-              depthLoadOp = loadOp,
-              depthStoreOp = storeOp,
-          }) {
-
-        assert.defined(colorTargets, 'colorAttachments');
-        assert.isArray(colorTargets, 'colorAttachments');
-
-        assert.isOneOf(loadOp, ['clear', 'load'], 'loadOp');
-        assert.isOneOf(storeOp, ['store', 'discard'], 'storeOp');
-
-
-        assert.isOneOf(colorLoadOp, ['clear', 'load'], 'colorLoadOp');
-        assert.isOneOf(colorStoreOp, ['store', 'discard'], 'colorStoreOp');
-
-        assert.isOneOf(depthLoadOp, ['clear', 'load'], 'depthLoadOp');
-        assert.isOneOf(depthStoreOp, ['store', 'discard'], 'depthStoreOp');
-
-        const _colorAttachments = [];
-
-        const color_target_count = colorTargets.length;
-        for (let i = 0; i < color_target_count; i++) {
-            const texture = colorTargets[i];
-
-            assert.defined(texture, 'texture');
-            assert.isObject(texture, 'texture');
-            assert.equal(texture.isGPUTextureContext, true, 'texture.isGPUTextureContext !== true');
-
-            const descriptor = this.colorAttachments[i];
-            _colorAttachments[i] = {
-                view: texture.obtainView(descriptor.view),
-                clearValue: descriptor.clearValue,
-                loadOp: colorLoadOp,
-                storeOp: colorStoreOp,
-            };
-        }
-
-        const depthDescriptor = this.depthStencilAttachment;
-
-
-        let _depthStencilAttachment;
-
-        if (depthTarget !== undefined) {
-            assert.equal(depthTarget.isGPUTextureContext, true, 'depthTarget.isGPUTextureContext !== true')
-
-            _depthStencilAttachment = {
-                view: depthTarget.obtainView(depthDescriptor.view),
-                depthClearValue: depthDescriptor.depthClearValue,
-                depthLoadOp: depthLoadOp,
-                depthStoreOp: depthStoreOp,
-            };
-
-        } else {
-
-            // no depth
-
-        }
-
-        return {
-            label: this.pipeline.label,
-            colorAttachments: _colorAttachments,
-            depthStencilAttachment: _depthStencilAttachment,
-        };
-    }
-
-    /**
-     *
-     * @param {Object} options
-     * @param {ShadeGPUCommandContext} options.encoder
-     * @param {GPUTextureContext[]} [options.colorTargets]
-     * @param {GPUTextureContext} [options.depthTarget]
-     * @param {Object} [options.bindings]
-     * @param {PrimitiveState} [options.primitive_state]
-     * @param {GPULoadOp} [options.loadOp="clear"] Used for both color targets and depth target
-     * @param {GPUStoreOp} [options.storeOp="store"] Used for both color targets and depth target
-     * @returns {ShadeGPURenderPassEncoder}
-     */
-    begin({
-              encoder,
-              colorTargets = [],
-              depthTarget,
-              bindings = {},
-        primitive_state,
-              loadOp = "clear",
-              storeOp = "store",
-          }) {
-        assert.defined(encoder, 'encoder');
-
-        assert.defined(bindings, 'bindings');
-        assert.isObject(bindings, 'bindings');
-
-        const gpu_descriptor = this.toGPU({
-            colorTargets,
-            depthTarget,
-            loadOp,
-            storeOp,
-        });
-
-        let pipeline = this.pipeline;
-
-        if(primitive_state !== undefined){
-            pipeline = rp_rewrite_for_primitive_state(pipeline,primitive_state);
-        }
-
-        return encoder.constructRenderPass({
-            pipeline,
-            bindings: this.resources.generateBindings(bindings),
-            immediate: encoder.writeImmediate(this.resources, bindings),
-            colorAttachments: gpu_descriptor.colorAttachments,
-            depthStencilAttachment: gpu_descriptor.depthStencilAttachment,
-        });
-    }
-
-    /**
-     *
-     * @param {Object} options
-     * @param {ShadeGPUCommandContext} options.encoder
-     * @param {GPUBuffer} options.command See {@link STRUCT_UNINDEXED_DRAW_COMMAND}
-     * @param {number} [options.command_offset]
-     * @param {Object} [options.bindings]
-     * @param {RenderTarget} options.render_target
-     */
-    drawIndirect({
-                     encoder,
-                     command,
-                     command_offset = 0,
-                     bindings = {},
-                     render_target
-                 }) {
-
-        const pass = this.begin({ encoder: encoder, render_target: render_target, bindings: bindings });
-
-        pass.drawIndirect(command, command_offset);
-
-        pass.end();
-
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
+import { assert } from "../../../../core/assert.js";
+import { rp_rewrite_for_primitive_state } from "../../../device/pipeline/rp_rewrite_for_primitive_state.js";
+import { RenderPassDepthStencilAttachmentDescriptor } from "./RenderPassDepthStencilAttachmentDescriptor.js";
+
+/**
+ * {@link GPURenderPassDescriptor}
+ */
+export class RenderPassDescriptor {
+    /**
+     * What the render pass is called. Unset, the pipeline's label names it, which is what a pass with
+     * one pipeline wants; a pass with a pipeline per material template has no one pipeline to take
+     * it from.
+     *
+     * @type {string|undefined}
+     */
+    label = undefined;
+
+    /**
+     * @type {RenderPipelineDescriptor}
+     */
+    pipeline
+
+    /**
+     * @type {ShaderResourceSetDescriptor}
+     */
+    resources
+
+    /**
+     *
+     * @type {RenderPassColorAttachmentDescriptor[]}
+     */
+    colorAttachments = [];
+
+    /**
+     *
+     * @type {RenderPassDepthStencilAttachmentDescriptor}
+     */
+    depthStencilAttachment = new RenderPassDepthStencilAttachmentDescriptor();
+
+
+    /**
+     * @param {Object} options
+     * @param {GPUTextureContext[]} [options.colorTargets]
+     * @param {GPUTextureContext} [options.depthTarget]
+     * @param {GPULoadOp} [options.loadOp="clear"] Used for both color targets and depth target
+     * @param {GPUStoreOp} [options.storeOp="store"] Used for both color targets and depth target
+     * @param {GPULoadOp} [options.colorLoadOp] defaults to `loadOp`
+     * @param {GPUStoreOp} [options.colorStoreOp] defaults to `storeOp`
+     * @param {GPULoadOp} [options.depthLoadOp] defaults to `loadOp`
+     * @param {GPUStoreOp} [options.depthStoreOp] defaults to `storeOp`
+     * @returns {GPURenderPassDescriptor}
+     */
+    toGPU({
+              colorTargets = [],
+              depthTarget,
+              loadOp = "clear",
+              storeOp = "store",
+              colorLoadOp = loadOp,
+              colorStoreOp = storeOp,
+              depthLoadOp = loadOp,
+              depthStoreOp = storeOp,
+          }) {
+
+        assert.defined(colorTargets, 'colorAttachments');
+        assert.isArray(colorTargets, 'colorAttachments');
+
+        assert.isOneOf(loadOp, ['clear', 'load'], 'loadOp');
+        assert.isOneOf(storeOp, ['store', 'discard'], 'storeOp');
+
+
+        assert.isOneOf(colorLoadOp, ['clear', 'load'], 'colorLoadOp');
+        assert.isOneOf(colorStoreOp, ['store', 'discard'], 'colorStoreOp');
+
+        assert.isOneOf(depthLoadOp, ['clear', 'load'], 'depthLoadOp');
+        assert.isOneOf(depthStoreOp, ['store', 'discard'], 'depthStoreOp');
+
+        const _colorAttachments = [];
+
+        const color_target_count = colorTargets.length;
+        for (let i = 0; i < color_target_count; i++) {
+            const texture = colorTargets[i];
+
+            assert.defined(texture, 'texture');
+            assert.isObject(texture, 'texture');
+            assert.equal(texture.isGPUTextureContext, true, 'texture.isGPUTextureContext !== true');
+
+            const descriptor = this.colorAttachments[i];
+            _colorAttachments[i] = {
+                view: texture.obtainView(descriptor.view),
+                clearValue: descriptor.clearValue,
+                loadOp: colorLoadOp,
+                storeOp: colorStoreOp,
+            };
+        }
+
+        const depthDescriptor = this.depthStencilAttachment;
+
+
+        let _depthStencilAttachment;
+
+        if (depthTarget !== undefined) {
+            assert.equal(depthTarget.isGPUTextureContext, true, 'depthTarget.isGPUTextureContext !== true')
+
+            _depthStencilAttachment = {
+                view: depthTarget.obtainView(depthDescriptor.view),
+                depthClearValue: depthDescriptor.depthClearValue,
+                depthLoadOp: depthLoadOp,
+                depthStoreOp: depthStoreOp,
+            };
+
+        } else {
+
+            // no depth
+
+        }
+
+        return {
+            label: this.label ?? this.pipeline.label,
+            colorAttachments: _colorAttachments,
+            depthStencilAttachment: _depthStencilAttachment,
+        };
+    }
+
+    /**
+     *
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {GPUTextureContext[]} [options.colorTargets]
+     * @param {GPUTextureContext} [options.depthTarget]
+     * @param {Object} [options.bindings]
+     * @param {PrimitiveState} [options.primitive_state]
+     * @param {GPULoadOp} [options.loadOp="clear"] Used for both color targets and depth target
+     * @param {GPUStoreOp} [options.storeOp="store"] Used for both color targets and depth target
+     * @returns {ShadeGPURenderPassEncoder}
+     */
+    begin({
+              encoder,
+              colorTargets = [],
+              depthTarget,
+              bindings = {},
+        primitive_state,
+              loadOp = "clear",
+              storeOp = "store",
+          }) {
+        assert.defined(encoder, 'encoder');
+
+        assert.defined(bindings, 'bindings');
+        assert.isObject(bindings, 'bindings');
+
+        const gpu_descriptor = this.toGPU({
+            colorTargets,
+            depthTarget,
+            loadOp,
+            storeOp,
+        });
+
+        let pipeline = this.pipeline;
+
+        if(primitive_state !== undefined){
+            pipeline = rp_rewrite_for_primitive_state(pipeline,primitive_state);
+        }
+
+        return encoder.constructRenderPass({
+            pipeline,
+            // the encoder resolves a `ShadeTexture` binding to a view, and is the only thing that
+            // can — dropping it here made a whole supported binding form unusable from this path
+            bindings: this.resources.generateBindings(bindings, encoder),
+            immediate: encoder.writeImmediate(this.resources, bindings),
+            colorAttachments: gpu_descriptor.colorAttachments,
+            depthStencilAttachment: gpu_descriptor.depthStencilAttachment,
+        });
+    }
+
+    /**
+     *
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {GPUBuffer} options.command See {@link STRUCT_UNINDEXED_DRAW_COMMAND}
+     * @param {number} [options.command_offset]
+     * @param {Object} [options.bindings]
+     * @param {RenderTarget} options.render_target
+     */
+    drawIndirect({
+                     encoder,
+                     command,
+                     command_offset = 0,
+                     bindings = {},
+                     render_target
+                 }) {
+
+        const pass = this.begin({ encoder: encoder, render_target: render_target, bindings: bindings });
+
+        pass.drawIndirect(command, command_offset);
+
+        pass.end();
+
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
 RenderPassDescriptor.prototype.isRenderPassDescriptor = true;

package/src/shade/renderer/shader/resource/ShaderResourceGroupDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderResourceGroupDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceGroupDescriptor.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AAEH;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAQV;;OAEG;IACH,4CAEC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,CAwGhC;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAc/B;IAED;;;;OAIG;IACH,6CAFa,mBAAmB,CA6B/B;IAED;;;OAGG;IACH,mDAHW,iBAAe,MAAM,GACnB,yBAAyB,CAqBrC;IAED;;;OAGG;IACH,gBAFY,MAAM,CAWjB;IAED;;;;OAIG;IACH,WAHW,MAAM,YACN,wBAAwB,QAUlC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,wBAAwB,GAAC,SAAS,CAiB9C;IAqDD;;;;;;OAMG;IACH,iBALW,MAAM,SACN,UAAU,GAAC,MAAM,wBAEf,IAAI,CAqChB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,QACN,UAAU,kBACV,OAAO,GACL,IAAI,CAmBhB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,mFAGN,OAAO,kBACP,YAAY,GACV,IAAI,CA8ChB;IAED;;;;;;;OAOG;IACH,wBANW,MAAM,qGAIL,6BAA6B,CAyBxC;IAED;;;;;;OAMG;IACH,iBALW,MAAM,gDAEN,iBAAiB,GACf,6BAA6B,CA4BzC;;CAEJ;gCA9fY,OAAO,kDAAkD,EAAE,iBAAiB;qCAC5E,OAAO,2CAA2C,EAAE,sBAAsB;2BAC1E,OAAO,+BAA+B,EAAE,YAAY;yBACpD,OAAO,uBAAuB,EAAE,UAAU;yCANd,+BAA+B;0CAV9B,0DAA0D"}
+{"version":3,"file":"ShaderResourceGroupDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceGroupDescriptor.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AAEH;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAQV;;OAEG;IACH,4CAEC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,CAoHhC;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAc/B;IAED;;;;OAIG;IACH,6CAFa,mBAAmB,CA6B/B;IAED;;;OAGG;IACH,mDAHW,iBAAe,MAAM,GACnB,yBAAyB,CAqBrC;IAED;;;OAGG;IACH,gBAFY,MAAM,CAWjB;IAED;;;;OAIG;IACH,WAHW,MAAM,YACN,wBAAwB,QAUlC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,wBAAwB,GAAC,SAAS,CAiB9C;IAqDD;;;;;;OAMG;IACH,iBALW,MAAM,SACN,UAAU,GAAC,MAAM,wBAEf,IAAI,CAqChB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,QACN,UAAU,kBACV,OAAO,GACL,IAAI,CAmBhB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,mFAGN,OAAO,kBACP,YAAY,GACV,IAAI,CA8ChB;IAED;;;;;;;OAOG;IACH,wBANW,MAAM,qGAIL,6BAA6B,CAyBxC;IAED;;;;;;OAMG;IACH,iBALW,MAAM,gDAEN,iBAAiB,GACf,6BAA6B,CA4BzC;;CAEJ;gCA1gBY,OAAO,kDAAkD,EAAE,iBAAiB;qCAC5E,OAAO,2CAA2C,EAAE,sBAAsB;2BAC1E,OAAO,+BAA+B,EAAE,YAAY;yBACpD,OAAO,uBAAuB,EAAE,UAAU;yCANd,+BAA+B;0CAV9B,0DAA0D"}

package/src/shade/renderer/shader/resource/ShaderResourceGroupDescriptor.js

@@ -132,6 +132,18 @@ export class ShaderResourceGroupDescriptor {
                 // TODO check for type match
 
                 if (binding_value.isShadeTexture === true) {
+                    // Not an assert: without it this is
+                    // `Cannot read properties of undefined (reading 'textures')` raised two files
+                    // from the binding that caused it, and the caller does not learn which binding
+                    // or that the encoder is the missing piece. `encoder` is optional and most
+                    // call sites leave it out, so this branch is reached with nothing there.
+                    if (encoder === undefined || encoder === null) {
+                        throw new Error(
+                            `Binding '${resource.name}' is a ShadeTexture, which only the encoder can`
+                            + ` resolve to a view, and generateBindings was called without one`
+                        );
+                    }
+
                     binding_value = encoder.textures.obtain(binding_value);
                 }
 

package/src/shade/renderer/shader/type/WebGPUArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGPUArray.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUArray.js"],"names":[],"mappings":"AAOA;IA0CI;;;;;OAKG;IACH,kBAJW,UAAU,UACV,MAAM,GACJ,WAAW,CAgBvB;IA7DD,cAAU;IAEV;;;OAGG;IACH,MAFU,UAAU,GAAC,IAAI,CAEb;IAYZ,4BAUC;IA8EL;;;OAGG;IACH,SAFU,OAAO,CAEY;;CAN5B;;aAUS,WAAW;aAMX,WAAW;eAMX,SAAS,WAAW,CAAC;eAMrB,SAAS,WAAW,CAAC;;2BAvIJ,iBAAiB"}
+{"version":3,"file":"WebGPUArray.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUArray.js"],"names":[],"mappings":"AAOA;IAkEI;;;;;OAKG;IACH,kBAJW,UAAU,UACV,MAAM,GACJ,WAAW,CAgBvB;IArFD,cAAU;IAEV;;;OAGG;IACH,MAFU,UAAU,GAAC,IAAI,CAEb;IAoCZ,4BAUC;IA8EL;;;OAGG;IACH,SAFU,OAAO,CAEY;;CAN5B;;aAUS,WAAW;aAMX,WAAW;eAMX,SAAS,WAAW,CAAC;eAMrB,SAAS,WAAW,CAAC;;2BA/JJ,iBAAiB"}

package/src/shade/renderer/shader/type/WebGPUArray.js

@@ -18,10 +18,34 @@ export class WebGPUArray extends WebGPUType {
         return this.type.align;
     }
 
+    /**
+     * Bytes this array occupies.
+     *
+     * A RUNTIME-SIZED one counts as a single element, which is WGSL rule for a type whose last
+     * member is unbounded and is the minimum binding size a caller sizing a binding wants.
+     *
+     * This was count * stride with no guard, and count is -1 for a runtime-sized array — the same
+     * -1 runtime_sized tests for — so it answered MINUS one stride. WebGPUStruct then does
+     * cursor = field.offset + field.size, which REWOUND past a trailing unbounded member: a struct
+     * of a u32 header and an array of f32 reported size 0, which is the worst possible wrong
+     * answer downstream. read_gpu_typed_buffer computes its default count as
+     * byteLength / aligned_size, which is Infinity; GPUTypedBuffer.from would ask for a zero-byte
+     * buffer; write_gpu_typed_buffer byteLength - offset >= type.size guard is vacuous. Every
+     * guard against runtime-sized types in this layer is an assert, stripped by the consumer, so
+     * in a shipped build the wrong number propagated rather than an error.
+     *
+     * @returns {number}
+     */
     get size() {
         const base_type = this.type;
 
-        return this.count * round_up(base_type.size, base_type.align)
+        const stride = round_up(base_type.size, base_type.align);
+
+        if (this.runtime_sized) {
+            return stride;
+        }
+
+        return this.count * stride;
     }
 
     equals(other) {

package/src/shade/renderer/shader/type/queue_typed_buffer_update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queue_typed_buffer_update.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/queue_typed_buffer_update.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,2GALW,MAAM,iCAGJ,IAAI,CA0ChB;AAED;;;;;GAKG;AACH,+FAFW,MAAM,QAgBhB"}
+{"version":3,"file":"queue_typed_buffer_update.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/queue_typed_buffer_update.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,2GALW,MAAM,iCAGJ,IAAI,CAyDhB;AAED;;;;;GAKG;AACH,+FAFW,MAAM,QAgBhB"}

package/src/shade/renderer/shader/type/queue_typed_buffer_update.js

@@ -35,6 +35,21 @@ export function queue_write_typed_buffer_data(
     if (write_size <= scratch_array_buffer.byteLength) {
         // most transient buffers have a small size, so we can avoid allocation by reusing a scratch
         cpu_buffer = scratch_array_buffer;
+
+        /*
+         Cleared, because the scratch is shared by every caller and every type and the whole
+         write_size range is uploaded below.
+
+         write_struct_value deliberately SKIPS a field the value does not name, so without this a
+         skipped field reached the GPU holding whatever the PREVIOUS call left at that offset — a
+         different struct, for a different buffer. ShaderResourceSetDescriptor#writeImmediate hit
+         exactly this and fixed it the same way; the uniform path next door did not. Every caller
+         today passes a complete value, so this is the trap the next partial one walks into, and it
+         would survive any review of the call site because the value LOOKS complete.
+
+         The allocated branch below needs no clearing: a fresh ArrayBuffer is already zero.
+        */
+        new Uint8Array(cpu_buffer, 0, write_size).fill(0);
     } else {
         cpu_buffer = new ArrayBuffer(write_size);
     }

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAsFA;;GAEG;AACH;IAgPI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EA+D5B;IApTD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IA2BtC;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA8ED;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAkGD;;;;;OAKG;IACH,iCAMC;IAgHD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAgE3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QAsFhC;IAsbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAwOnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAiBC;;CACJ;qCAn9CY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;oCA9DX,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAuFA;;GAEG;AACH;IAgPI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EA+D5B;IApTD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IA2BtC;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA8ED;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAkGD;;;;;OAKG;IACH,iCAMC;IAgHD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAgE3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QAsFhC;IAsbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAwOnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAiBC;;CACJ;qCAn9CY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;oCA9DX,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}