@woosh/meep-engine 3.29.0 → 3.31.0

package/src/shade/device/mock/SoftwareGPUBindGroup.d.ts

@@ -5,16 +5,53 @@
  */
 export class SoftwareGPUBindGroup extends SoftwareGPUObjectBase implements GPUBindGroup {
     /**
+     * The bind group a device hands back for a descriptor it rejected.
+     *
      * @param {GPUBindGroupDescriptor} descriptor
+     * @returns {SoftwareGPUBindGroup}
      */
-    constructor(descriptor: GPUBindGroupDescriptor);
+    static invalid(descriptor: GPUBindGroupDescriptor): SoftwareGPUBindGroup;
+    /**
+     * @param {GPUBindGroupDescriptor} descriptor
+     * @param {boolean} [valid] whether the device accepted `descriptor`; see {@link isValid}
+     */
+    constructor(descriptor: GPUBindGroupDescriptor, valid?: boolean);
+    /**
+     * Whether the device accepted the descriptor this was made from. See
+     * {@link SoftwareGPUBuffer#isValid} — WebGPU hands back a bind group for a descriptor it
+     * rejects, and a pass that sets it is invalidated by it.
+     *
+     * @return {boolean}
+     */
+    get isValid(): boolean;
     layout: any;
     entries: any;
+    /**
+     * The textures the entries name — a view's texture, or a texture bound as itself, which WebGPU
+     * takes as its default view.
+     *
+     * WebGPU asks at `submit()`, and not before, whether a texture named by a bind group the command
+     * buffer set has been destroyed; this is the list it asks about.
+     *
+     * @returns {SoftwareGPUTexture[]}
+     */
+    get textures(): SoftwareGPUTexture[];
+    /**
+     * The buffers the entries name — bound as a {@link GPUBufferBinding}, or as the buffer itself,
+     * which WebGPU takes as a binding of the whole buffer.
+     *
+     * WebGPU asks at `submit()`, and not before, whether a buffer named by a bind group the command
+     * buffer set is still available — neither destroyed nor mapped; this is the list it asks about.
+     *
+     * @returns {SoftwareGPUBuffer[]}
+     */
+    get buffers(): SoftwareGPUBuffer[];
     /**
      * @readonly
      * @type {boolean}
      */
     readonly isSoftwareGPUBindGroup: boolean;
+    #private;
 }
 import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
 //# sourceMappingURL=SoftwareGPUBindGroup.d.ts.map

package/src/shade/device/mock/SoftwareGPUBindGroup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUBindGroup.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUBindGroup.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,2EAFgB,YAAY;IAGxB;;OAEG;IACH,gDAIC;IAFG,YAA+B;IAC/B,aAAiC;IAIzC;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;sCAhBqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUBindGroup.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUBindGroup.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,2EAFgB,YAAY;IA2BxB;;;;;OAKG;IACH,oDAFa,oBAAoB,CAIhC;IAnBD;;;OAGG;IACH,wDAFW,OAAO,EAOjB;IApBD;;;;;;OAMG;IACH,uBAEC;IASG,YAA+B;IAC/B,aAAiC;IAarC;;;;;;;;OAQG;IACH,qCAYC;IAED;;;;;;;;OAQG;IACH,mCAYC;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;;CANpD;sCAxFqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUBindGroup.js

@@ -1,4 +1,5 @@
 import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
+import { texture_view_resource_texture } from "./texture_view_resource.js";
 
 /**
  * Emulates {@link GPUBindGroup}. Stores the layout + entries it was created from; no GPU state.
@@ -6,14 +7,85 @@ import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
  * @implements {GPUBindGroup}
  */
 export class SoftwareGPUBindGroup extends SoftwareGPUObjectBase {
+    #valid = true;
+
+    /**
+     * Whether the device accepted the descriptor this was made from. See
+     * {@link SoftwareGPUBuffer#isValid} — WebGPU hands back a bind group for a descriptor it
+     * rejects, and a pass that sets it is invalidated by it.
+     *
+     * @return {boolean}
+     */
+    get isValid() {
+        return this.#valid;
+    }
+
     /**
      * @param {GPUBindGroupDescriptor} descriptor
+     * @param {boolean} [valid] whether the device accepted `descriptor`; see {@link isValid}
      */
-    constructor(descriptor) {
+    constructor(descriptor, valid = true) {
         super(descriptor);
+        this.#valid = valid;
         this.layout = descriptor.layout;
         this.entries = descriptor.entries;
     }
+
+    /**
+     * The bind group a device hands back for a descriptor it rejected.
+     *
+     * @param {GPUBindGroupDescriptor} descriptor
+     * @returns {SoftwareGPUBindGroup}
+     */
+    static invalid(descriptor) {
+        return new SoftwareGPUBindGroup(descriptor, false);
+    }
+
+    /**
+     * The textures the entries name — a view's texture, or a texture bound as itself, which WebGPU
+     * takes as its default view.
+     *
+     * WebGPU asks at `submit()`, and not before, whether a texture named by a bind group the command
+     * buffer set has been destroyed; this is the list it asks about.
+     *
+     * @returns {SoftwareGPUTexture[]}
+     */
+    get textures() {
+        const textures = [];
+
+        for (const { resource } of this.entries) {
+            const texture = texture_view_resource_texture(resource);
+
+            if (texture !== undefined) {
+                textures.push(texture);
+            }
+        }
+
+        return textures;
+    }
+
+    /**
+     * The buffers the entries name — bound as a {@link GPUBufferBinding}, or as the buffer itself,
+     * which WebGPU takes as a binding of the whole buffer.
+     *
+     * WebGPU asks at `submit()`, and not before, whether a buffer named by a bind group the command
+     * buffer set is still available — neither destroyed nor mapped; this is the list it asks about.
+     *
+     * @returns {SoftwareGPUBuffer[]}
+     */
+    get buffers() {
+        const buffers = [];
+
+        for (const { resource } of this.entries) {
+            const buffer = resource?.isSoftwareGPUBuffer === true ? resource : resource?.buffer;
+
+            if (buffer?.isSoftwareGPUBuffer === true) {
+                buffers.push(buffer);
+            }
+        }
+
+        return buffers;
+    }
 }
 
 /**

package/src/shade/device/mock/SoftwareGPUBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUBuffer.js"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AAEH;;;GAGG;AACH,wEAFgB,SAAS;IAiJrB;;;;;;;OAOG;IACH,4EAFa,iBAAiB,CAI7B;IA5CD;;;;;OAKG;IACH,gFAFW,OAAO,EA4BjB;IAlID;;;OAGG;IACH,mBAEC;IAID;;;OAGG;IACH,8BAEC;IAQD;;;OAGG;IACH,kCAEC;IA4BD;;;;;;;;OAQG;IACH,wBAEC;IAID;;;;;;;;;;OAUG;IACH,uBAEC;IAID;;;OAGG;IACH,2BAEC;IA0HD;;;;;;;;;;;;OAYG;IACH,yCALW,MAAM,SACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAoB9B;IAsCD;;;;;;;;;;;;;;;OAeG;IACH,wBAPW,MAAM,SACN,MAAM,GAIJ,WAAW,CAgBvB;IAED;;;;OAIG;IACH,cAYC;IAED;;;;;;;OAOG;IACH,gBAYC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;YA1Xa,MAAM;;;;UACN,MAAM;;;;UACN,WAAW;;sCAtBa,4BAA4B"}
+{"version":3,"file":"SoftwareGPUBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUBuffer.js"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AAEH;;;GAGG;AACH,wEAFgB,SAAS;IAiJrB;;;;;;;OAOG;IACH,4EAFa,iBAAiB,CAI7B;IA5CD;;;;;OAKG;IACH,gFAFW,OAAO,EA4BjB;IAlID;;;OAGG;IACH,mBAEC;IAID;;;OAGG;IACH,8BAEC;IAQD;;;OAGG;IACH,kCAEC;IA4BD;;;;;;;;OAQG;IACH,wBAEC;IAID;;;;;;;;;;OAUG;IACH,uBAEC;IAID;;;OAGG;IACH,2BAEC;IA0HD;;;;;;;;;;;;OAYG;IACH,yCALW,MAAM,SACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAoB9B;IAsCD;;;;;;;;;;;;;;;OAeG;IACH,wBAPW,MAAM,SACN,MAAM,GAIJ,WAAW,CAgBvB;IAED;;;;OAIG;IACH,cAYC;IAED;;;;;;;OAOG;IACH,gBAiBC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;YA/Xa,MAAM;;;;UACN,MAAM;;;;UACN,WAAW;;sCAtBa,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUBuffer.js

@@ -397,6 +397,11 @@ export class SoftwareGPUBuffer extends SoftwareGPUObjectBase {
         this.#mapped_ranges = [];
         this.#mapState = "unmapped";
         this.#destroyed = true;
+
+        // and the storage goes with it. The texture already drops its mip data here; the buffer
+        // kept handing `data` out, so anything still holding the buffer could read and write
+        // memory the caller believes it released.
+        this.#data = null;
     }
 }
 

package/src/shade/device/mock/SoftwareGPUCommandBuffer.d.ts

@@ -33,6 +33,40 @@ export class SoftwareGPUCommandBuffer implements GPUCommandBuffer {
      * @return {boolean}
      */
     get isValid(): boolean;
+    /**
+     * The first resource named by anything encoded here that has since been destroyed, or `null`
+     * when they are all still alive.
+     *
+     * WebGPU validates a submission against the resources it names, so destroying one between
+     * `finish()` and `submit()` makes the submission a validation error that executes none of it.
+     * The encode-time refusals cannot see that — they ran before the destruction — and the
+     * `execute()` closures read `.data` off the captured object, so the copy went through into
+     * storage the caller believes it released.
+     *
+     * A render pass's attachments are here too, and so are the textures and buffers its bind groups
+     * name and the vertex, index and indirect buffers a pass is given. For them this is the only
+     * check: WebGPU does not refuse a destroyed texture's view, a bind group over a destroyed
+     * resource, a pass pointed at one or a pass given a destroyed buffer, only the submission that
+     * uses them.
+     *
+     * @returns {{isDestroyed:boolean,label:string}|null}
+     */
+    destroyed_resource(): {
+        isDestroyed: boolean;
+        label: string;
+    } | null;
+    /**
+     * The first buffer named by anything encoded here that is mapped, or has a `mapAsync` still
+     * pending, or `null` when none is.
+     *
+     * WebGPU asks that every buffer a submission uses be "available", and a mapped buffer is not:
+     * `mapAsync` takes it out of the queue's hands until `unmap()` gives it back, pending or not, and
+     * so does `mappedAtCreation`. A pass is given a mapped buffer without complaint and a copy's
+     * buffer may be mapped after `finish()`, so this is where either is caught.
+     *
+     * @returns {SoftwareGPUBuffer|null}
+     */
+    mapped_buffer(): SoftwareGPUBuffer | null;
     execute(): void;
     #private;
 }

package/src/shade/device/mock/SoftwareGPUCommandBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUCommandBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUCommandBuffer.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,iDAFgB,gBAAgB;IA2C5B;;;;;OAKG;IACH,kBAFa,wBAAwB,CAIpC;IAlBD;;;;OAIG;IACH,sBAHW;QAAC,OAAO,WAAS;KAAC,EAAE,UACpB,OAAO,EAKjB;IA9BD;;;;;OAKG;IACH,0BAEC;IAID;;;;;OAKG;IACH,uBAEC;IAsBD,gBAUC;;CACJ"}
+{"version":3,"file":"SoftwareGPUCommandBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUCommandBuffer.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,iDAFgB,gBAAgB;IAiH5B;;;;;OAKG;IACH,kBAFa,wBAAwB,CAIpC;IAlBD;;;;OAIG;IACH,sBAHW;QAAC,OAAO,WAAS;KAAC,EAAE,UACpB,OAAO,EAKjB;IApGD;;;;;OAKG;IACH,0BAEC;IAID;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sBAFa;QAAC,WAAW,EAAC,OAAO,CAAC;QAAA,KAAK,EAAC,MAAM,CAAA;KAAC,GAAC,IAAI,CAUnD;IAED;;;;;;;;;;OAUG;IACH,iBAFa,oBAAkB,IAAI,CAUlC;IA2CD,gBAUC;;CACJ"}

package/src/shade/device/mock/SoftwareGPUCommandBuffer.js

@@ -6,7 +6,7 @@
 export class SoftwareGPUCommandBuffer {
     /**
      *
-     * @type {{execute:function}[]}
+     * @type {{resources?:{isDestroyed:boolean,label:string}[], execute:function}[]}
      */
     #commands = []
 
@@ -34,6 +34,76 @@ export class SoftwareGPUCommandBuffer {
         return this.#valid;
     }
 
+    /**
+     * The first resource named by anything encoded here that has since been destroyed, or `null`
+     * when they are all still alive.
+     *
+     * WebGPU validates a submission against the resources it names, so destroying one between
+     * `finish()` and `submit()` makes the submission a validation error that executes none of it.
+     * The encode-time refusals cannot see that — they ran before the destruction — and the
+     * `execute()` closures read `.data` off the captured object, so the copy went through into
+     * storage the caller believes it released.
+     *
+     * A render pass's attachments are here too, and so are the textures and buffers its bind groups
+     * name and the vertex, index and indirect buffers a pass is given. For them this is the only
+     * check: WebGPU does not refuse a destroyed texture's view, a bind group over a destroyed
+     * resource, a pass pointed at one or a pass given a destroyed buffer, only the submission that
+     * uses them.
+     *
+     * @returns {{isDestroyed:boolean,label:string}|null}
+     */
+    destroyed_resource() {
+        for (const resource of this.#resources()) {
+            if (resource.isDestroyed) {
+                return resource;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * The first buffer named by anything encoded here that is mapped, or has a `mapAsync` still
+     * pending, or `null` when none is.
+     *
+     * WebGPU asks that every buffer a submission uses be "available", and a mapped buffer is not:
+     * `mapAsync` takes it out of the queue's hands until `unmap()` gives it back, pending or not, and
+     * so does `mappedAtCreation`. A pass is given a mapped buffer without complaint and a copy's
+     * buffer may be mapped after `finish()`, so this is where either is caught.
+     *
+     * @returns {SoftwareGPUBuffer|null}
+     */
+    mapped_buffer() {
+        for (const resource of this.#resources()) {
+            if (resource.isSoftwareGPUBuffer === true && resource.mapState !== "unmapped") {
+                return resource;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Every resource named by anything encoded here, in encode order.
+     *
+     * @returns {Generator<{isDestroyed:boolean,label:string}>}
+     */
+    *#resources() {
+        for (const command of this.#commands) {
+            const resources = command.resources;
+
+            if (resources === undefined) {
+                continue;
+            }
+
+            for (const resource of resources) {
+                if (resource !== undefined && resource !== null) {
+                    yield resource;
+                }
+            }
+        }
+    }
+
     /**
      *
      * @param {{execute:function}[]} commands

package/src/shade/device/mock/SoftwareGPUCommandEncoder.d.ts

@@ -65,6 +65,21 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase implements
      * @returns {GPUComputePassEncoder}
      */
     beginComputePass(descriptor?: GPUComputePassDescriptor): GPUComputePassEncoder;
+    /**
+     * Called by a pass this encoder opened, with the resources a command it took uses — the textures
+     * and buffers a bind group it set names, and a vertex, index or indirect buffer it was given.
+     *
+     * WebGPU asks about those at `submit()` and not before: a texture destroyed, or a buffer
+     * destroyed or mapped, before the pass was encoded is still bound and drawn with without
+     * complaint, and it is the submission that fails. So they are recorded the way a copy records
+     * what it names, as a command that runs nothing, for
+     * {@link SoftwareGPUCommandBuffer#destroyed_resource} and
+     * {@link SoftwareGPUCommandBuffer#mapped_buffer} to ask about.
+     *
+     * @param {(SoftwareGPUTexture|SoftwareGPUBuffer)[]} resources
+     * @returns {void}
+     */
+    notify_pass_uses(resources: (SoftwareGPUTexture | SoftwareGPUBuffer)[]): void;
     /**
      * Begin a render pass. The pass **records** and rasterizes nothing — see
      * {@link SoftwareGPURenderPassEncoder}. Every pass begun on this encoder stays on

package/src/shade/device/mock/SoftwareGPUCommandEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUCommandEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUCommandEncoder.js"],"names":[],"mappings":"AA2DA;;;;GAIG;AACH,gFAFgB,iBAAiB;IA+D7B;;;;OAIG;IACH,iFAIC;IAzDD;;;;OAIG;IACH,gBAFU,6BAA6B,EAAE,CAErB;IAEpB;;;;OAIG;IACH,eAFU,4BAA4B,EAAE,CAErB;IAEnB;;;;;;OAMG;IACH,QAFU,CAAC,6BAA6B,GAAC,4BAA4B,CAAC,EAAE,CAE5D;IA0EZ,mCAiBC;IAkBD;;;;;OAKG;IACH,wBAHW,6BAA6B,GAAC,4BAA4B,GACxD,IAAI,CAMhB;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;;;;OASG;IACH,sCAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;OAOG;IACH,+EAeC;IAED;;;;;;;OAOG;IACH,4EAaC;IAED;;;;;;;;OAQG;IACH,oHAFa,IAAI,CAsBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAsBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAsBhB;IAED;;;;;;;;;OASG;IACH,2DANW,MAAM,cACN,MAAM,qDAEN,MAAM,GACJ,IAAI,CAuBhB;IAwCD;;;;OAIG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAyED;;;;;;;;OAQG;IACH,4DANW,MAAM,qDAEN,MAAM,QACN,MAAM,GACJ,IAAI,CA+BhB;IAED;;;;;;;OAOG;IACH,gDAJW,MAAM,SACN,MAAM,GACJ,IAAI,CA4BhB;IAGL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;;CAN9D;sCAnmBqC,4BAA4B;8CAFpB,oCAAoC;6CAGrC,mCAAmC;yCAJvC,+BAA+B"}
+{"version":3,"file":"SoftwareGPUCommandEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUCommandEncoder.js"],"names":[],"mappings":"AAgGA;;;;GAIG;AACH,gFAFgB,iBAAiB;IA+D7B;;;;OAIG;IACH,iFAIC;IAzDD;;;;OAIG;IACH,gBAFU,6BAA6B,EAAE,CAErB;IAEpB;;;;OAIG;IACH,eAFU,4BAA4B,EAAE,CAErB;IAEnB;;;;;;OAMG;IACH,QAFU,CAAC,6BAA6B,GAAC,4BAA4B,CAAC,EAAE,CAE5D;IA0EZ,mCAiBC;IAqBD;;;;;OAKG;IACH,wBAHW,6BAA6B,GAAC,4BAA4B,GACxD,IAAI,CAMhB;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;;;;OASG;IACH,sCAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;OAOG;IACH,+EAeC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAHW,CAAC,sCAAoC,CAAC,EAAE,GACtC,IAAI,CAUhB;IAkBD;;;;;;;OAOG;IACH,4EAmCC;IAED;;;;;;;;OAQG;IACH,oHAFa,IAAI,CAuBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAuBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAuBhB;IAED;;;;;;;;;OASG;IACH,2DANW,MAAM,cACN,MAAM,qDAEN,MAAM,GACJ,IAAI,CAwBhB;IAwCD;;;;OAIG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAyED;;;;;;;;OAQG;IACH,4DANW,MAAM,qDAEN,MAAM,QACN,MAAM,GACJ,IAAI,CAgChB;IAED;;;;;;;OAOG;IACH,gDAJW,MAAM,SACN,MAAM,GACJ,IAAI,CA6BhB;IAGL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;;CAN9D;sCA/sBqC,4BAA4B;8CAFpB,oCAAoC;6CAGrC,mCAAmC;yCAJvC,+BAA+B"}

package/src/shade/device/mock/SoftwareGPUCommandEncoder.js

@@ -5,6 +5,7 @@ import { SoftwareGPUValidationError } from "./SoftwareGPUError.js";
 import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
 import { SoftwareGPURenderPassEncoder } from "./SoftwareGPURenderPassEncoder.js";
 import { texture_copy_execute, texture_copy_refusal } from "./texture_copy.js";
+import { texture_view_resource_refusal, texture_view_resource_texture } from "./texture_view_resource.js";
 
 /**
  * Buffer copies work in whole 4-byte words, on offsets and size alike. See
@@ -57,6 +58,42 @@ function buffer_copy_refusal(buffer, role, required_usage, required_usage_name)
     return null;
 }
 
+/**
+ * Every view a render pass descriptor points at — or texture, which WebGPU takes in place of its
+ * default view — named by where in the descriptor it sits, for a message to say which one it was.
+ *
+ * @param {GPURenderPassDescriptor} descriptor
+ * @returns {{role: string, resource: SoftwareGPUTextureView|SoftwareGPUTexture}[]}
+ */
+function render_pass_attachments(descriptor) {
+    const attachments = [];
+
+    const color_attachments = descriptor.colorAttachments ?? [];
+
+    for (let i = 0; i < color_attachments.length; i++) {
+        const color = color_attachments[i];
+
+        // a sparse colour attachment list is legal; the hole is a slot the pipeline does not write
+        if (color === null || color === undefined) {
+            continue;
+        }
+
+        attachments.push({ role: `colorAttachments[${i}].view`, resource: color.view });
+
+        if (color.resolveTarget !== undefined && color.resolveTarget !== null) {
+            attachments.push({ role: `colorAttachments[${i}].resolveTarget`, resource: color.resolveTarget });
+        }
+    }
+
+    const depth_stencil = descriptor.depthStencilAttachment;
+
+    if (depth_stencil !== undefined && depth_stencil !== null) {
+        attachments.push({ role: 'depthStencilAttachment.view', resource: depth_stencil.view });
+    }
+
+    return attachments;
+}
+
 /**
  * Emulates {@link GPUCommandEncoder}
  *
@@ -196,8 +233,11 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
     }
 
     /**
+     * Record a command. `resources` is what the command names — the queue re-checks them at submit
+     * time, because a resource destroyed after `finish()` is a validation error there and the
+     * encode-time refusals cannot see it.
      *
-     * @param command
+     * @param {{resources?:{isDestroyed:boolean,label:string}[], execute:function}} command
      */
     #encode(command) {
         this.#assert_encoding();
@@ -266,6 +306,46 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
         return pass;
     }
 
+    /**
+     * Called by a pass this encoder opened, with the resources a command it took uses — the textures
+     * and buffers a bind group it set names, and a vertex, index or indirect buffer it was given.
+     *
+     * WebGPU asks about those at `submit()` and not before: a texture destroyed, or a buffer
+     * destroyed or mapped, before the pass was encoded is still bound and drawn with without
+     * complaint, and it is the submission that fails. So they are recorded the way a copy records
+     * what it names, as a command that runs nothing, for
+     * {@link SoftwareGPUCommandBuffer#destroyed_resource} and
+     * {@link SoftwareGPUCommandBuffer#mapped_buffer} to ask about.
+     *
+     * @param {(SoftwareGPUTexture|SoftwareGPUBuffer)[]} resources
+     * @returns {void}
+     */
+    notify_pass_uses(resources) {
+        if (this.#is_finished) {
+            // a pass still encoding after its encoder finished reaches no command buffer: WebGPU
+            // hands a pass's bind groups to its encoder when the pass ends, and refuses that end
+            return;
+        }
+
+        this.#uses(resources);
+    }
+
+    /**
+     * Record resources a submission of this encoder's work must find alive, and unmapped if they are
+     * buffers.
+     *
+     * @param {(SoftwareGPUTexture|SoftwareGPUBuffer)[]} resources
+     * @returns {void}
+     */
+    #uses(resources) {
+        this.#encode({
+            resources,
+            execute() {
+                // the pass that uses them rasterizes and dispatches nothing
+            }
+        });
+    }
+
     /**
      * Begin a render pass. The pass **records** and rasterizes nothing — see
      * {@link SoftwareGPURenderPassEncoder}. Every pass begun on this encoder stays on
@@ -279,6 +359,28 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
 
         this.#check_unlocked('beginRenderPass');
 
+        const attachments = render_pass_attachments(descriptor);
+
+        for (const { role, resource } of attachments) {
+            const refusal = texture_view_resource_refusal(resource, role);
+
+            if (refusal !== null) {
+                /*
+                 WebGPU invalidates the pass for an attachment that is not valid to use with the
+                 device, and the pass invalidates this encoder when it ends, so the error surfaces
+                 from finish(). Invalidating here directly is what a pass's own failures do too —
+                 see notify_pass_validation_error. The pass is still handed back, and still locks
+                 the encoder, as WebGPU's does.
+                */
+                this.#invalidate(`beginRenderPass: ${refusal}`);
+
+                break;
+            }
+        }
+
+        // a destroyed attachment is not refused until the command buffer is submitted
+        this.#uses(attachments.map(({ resource }) => texture_view_resource_texture(resource)));
+
         const pass = new SoftwareGPURenderPassEncoder(this, descriptor);
 
         this.#open_pass = pass;
@@ -314,6 +416,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
         }
 
         this.#encode({
+            resources: [source.texture, destination.texture],
             execute() {
                 texture_copy_execute({ texture_source: source, texture_destination: destination, size: copySize });
             }
@@ -342,6 +445,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
         }
 
         this.#encode({
+            resources: [source.buffer, destination.texture],
             execute() {
                 texture_copy_execute({ buffer_source: source, texture_destination: destination, size: copySize });
             }
@@ -370,6 +474,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
         }
 
         this.#encode({
+            resources: [source.texture, destination.buffer],
             execute() {
                 texture_copy_execute({ texture_source: source, buffer_destination: destination, size: copySize });
             }
@@ -402,6 +507,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
         }
 
         this.#encode({
+            resources: [querySet, destination],
             execute() {
                 new BigInt64Array(destination.data, destinationOffset, queryCount)
                     .set(querySet.read(firstQuery, queryCount));
@@ -572,6 +678,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
         }
 
         this.#encode({
+            resources: [source, destination],
             execute() {
                 array_buffer_copy(source.data, sourceOffset, destination.data, destinationOffset, _size);
             }
@@ -608,6 +715,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
         }
 
         this.#encode({
+            resources: [buffer],
             execute() {
                 new Uint8Array(buffer.data, offset, clear_size).fill(0);
             }

package/src/shade/device/mock/SoftwareGPUComputePassEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUComputePassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUComputePassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,oFAFgB,qBAAqB;IA6DjC;;;OAGG;IACH,uFAQC;IAtED;;;;OAIG;IACH,YAFU;QAAC,QAAQ,EAAE,qBAAmB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAC,EAAE,CAEjI;IAEhB;;;;;OAKG;IACH,qCAAW;IAoCX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,gDAIC;IAED;;;;;;;;;OASG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QAWhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IAkCD;;;;OAIG;IACH,sBAJW,MAAM,MACN,MAAM,MACN,MAAM,QAWhB;IAED;;;OAGG;IACH,wEAFW,MAAM,QAahB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,0CAFU,OAAO,CAEsD;;CANtE;sCA1OqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUComputePassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUComputePassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,oFAFgB,qBAAqB;IA6DjC;;;OAGG;IACH,uFAQC;IAtED;;;;OAIG;IACH,YAFU;QAAC,QAAQ,EAAE,qBAAmB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAC,EAAE,CAEjI;IAEhB;;;;;OAKG;IACH,qCAAW;IAoCX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,gDAIC;IAED;;;;;;;;;OASG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IA4DD;;;;OAIG;IACH,sBAJW,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,wEAFW,MAAM,QAsBhB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,0CAFU,OAAO,CAEsD;;CANtE;sCA7RqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUComputePassEncoder.js

@@ -119,6 +119,21 @@ export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase {
     setBindGroup(index, bind_group, dynamic_offsets, dynamic_offsets_start, dynamic_offsets_length) {
         this.#assert_encoding();
 
+        // `null` empties the slot, which WebGPU allows. Setting a group is what puts its textures and
+        // buffers in front of the submission, dispatched with or not
+        if (bind_group !== null && bind_group !== undefined) {
+            if (!bind_group.isValid) {
+                // WebGPU invalidates the pass, which invalidates the encoder when it ends
+                this.#encoder.notify_pass_validation_error(
+                    `setBindGroup: bind group '${bind_group.label}' at index ${index} is invalid`
+                );
+
+                return;
+            }
+
+            this.#encoder.notify_pass_uses([...bind_group.textures, ...bind_group.buffers]);
+        }
+
         this.#bind_groups[index] = bind_group;
         this.#dynamic_offsets[index] = normalize_dynamic_offsets(
             dynamic_offsets,
@@ -175,6 +190,32 @@ export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase {
         }
     }
 
+    /**
+     * WebGPU refuses a dispatch on a pass with no pipeline, and one whose group count in any
+     * dimension is above the device's `maxComputeWorkgroupsPerDimension`. Neither was checked: the
+     * counts were recorded verbatim, so a pass deriving its count as `ceil(n / workgroup_size)`
+     * from a large element count passed this tier and, in a browser, invalidated the encoder and
+     * dropped the whole submission without encoding anything. This engine has tripped that ceiling
+     * before, on a per-meshlet dispatch.
+     *
+     * @returns {void}
+     */
+    #validate_dispatch(x, y, z) {
+        if (this.#pipeline === null) {
+            this.#encoder.notify_pass_validation_error('dispatch: no pipeline was set on the pass');
+
+            return;
+        }
+
+        const limit = this.#encoder.device.limits.maxComputeWorkgroupsPerDimension;
+
+        if (x > limit || y > limit || z > limit) {
+            this.#encoder.notify_pass_validation_error(
+                `dispatch: group counts [${x}, ${y}, ${z}] exceed maxComputeWorkgroupsPerDimension ${limit}`
+            );
+        }
+    }
+
     /**
      * @param {number} x
      * @param {number} [y]
@@ -182,6 +223,7 @@ export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase {
      */
     dispatchWorkgroups(x, y = 1, z = 1) {
         this.#assert_encoding();
+        this.#validate_dispatch(x, y, z);
         this.#validate_immediates();
 
         this.dispatches.push({
@@ -197,8 +239,17 @@ export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase {
      */
     dispatchWorkgroupsIndirect(indirect_buffer, indirect_offset) {
         this.#assert_encoding();
+
+        // the counts live in a buffer a shader wrote, so the limit is the driver's problem at
+        // execution time and not ours; the pipeline still has to be there
+        if (this.#pipeline === null) {
+            this.#encoder.notify_pass_validation_error('dispatch: no pipeline was set on the pass');
+        }
+
         this.#validate_immediates();
 
+        this.#encoder.notify_pass_uses([indirect_buffer]);
+
         // The group counts live in a buffer a shader wrote, which nothing here executed — recording
         // a count read out of it would be fiction, so the entry says what it is.
         this.dispatches.push({

package/src/shade/device/mock/SoftwareGPUDevice.d.ts

@@ -195,8 +195,12 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase implements GPUDevic
      */
     createBindGroupLayout(descriptor: GPUBindGroupLayoutDescriptor): GPUBindGroupLayout;
     /**
+     * A bind group naming a resource the device refused is reported through the error scopes and
+     * answered with an invalid bind group, the same way {@link createBuffer} answers a descriptor it
+     * will not honour — and a pass that sets it fails with it, at the encoder's `finish()`.
+     *
      * @param {GPUBindGroupDescriptor} descriptor
-     * @returns {GPUBindGroup}
+     * @returns {GPUBindGroup} invalid when the descriptor was refused
      */
     createBindGroup(descriptor: GPUBindGroupDescriptor): GPUBindGroup;
     /**

package/src/shade/device/mock/SoftwareGPUDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AAoQA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;;;OAUG;IACH;QAT+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAyBrC;IAzDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAmCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAwID;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;OAGG;IACH,kEAEC;IAED;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WAxpBa,mBAAiB,IAAI;;sCAnQG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}
+{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AAsQA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;;;OAUG;IACH;QAT+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAyBrC;IAzDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAmCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAmJD;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;;;;;OAOG;IACH,kEAUC;IAkCD;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WA/sBa,mBAAiB,IAAI;;sCArQG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}