@driftengine/core 4.1.0 → 4.1.2

package/CHANGELOG.json

@@ -1,4 +1,31 @@
 [
+  {
+    "version": "4.1.2",
+    "date": "2026-09-20",
+    "entries": [
+      {
+        "kind": "fixed",
+        "short": "A device that refuses the transparent pipeline loses the glass, not the frame. It was taking the whole command buffer with it, so a phone drew nothing where it could have drawn everything else.",
+        "text": "**Reported from a Galaxy S23 Ultra, on the published site.** `CreateGraphicsPipelines failed with VK_ERROR_UNKNOWN` for `gpu-driven blend`, and then four more errors that were all the same one: an invalid pipeline makes an invalid bind group, which makes an invalid encoder, which makes an invalid command buffer. **The city drew nothing, on a device that could have drawn all of it but the glass.**\n\n**`createRenderPipeline` does not throw where a driver refuses it.** It hands back an *invalid* handle and reports asynchronously, so there is nothing to catch at the call and the code after it carried on: a bind group built from the invalid layout, a pass set to the invalid pipeline, a submit of the invalid buffer. Two `as GPURenderPipeline` casts are where that assumption lived.\n\n**So the pipeline is built inside error scopes and disowned where one comes back.** Both scopes, validation and internal, because a shader a driver cannot compile is reported as one on some backends and the other elsewhere, and this is exactly the case where guessing costs the whole frame. The transparent pass then skips itself and everything opaque still draws. The warning is said once, in the words the device used.\n\n**The check that went with it had to be rewritten before it meant anything.** The first version asserted that no transparent draw was encoded, and it could not have failed: the fixture carries nothing transparent, so that draw is absent either way and it passed over an unfixed pass. What is observable is the warning and the frame, so that is what it asserts, and perturbing the disown turns it red.\n\n**What is not fixed is why that driver refuses the pipeline.** Its targets are `rgba16float` and `r8unorm` under `layout: auto`, and diagnosing `VK_ERROR_UNKNOWN` needs the part that produces it. This is the containment: a refusal costs what it is about."
+      }
+    ]
+  },
+  {
+    "version": "4.1.1",
+    "date": "2026-09-20",
+    "entries": [
+      {
+        "kind": "added",
+        "short": "Two adapters, so the inspector and the network panel have something to read. An entity world becomes inspectable and a lockstep session becomes a readout, both typed by shape rather than by import.",
+        "text": "**A panel needs its world in the shape the panel reads, and two of those shapes are the same in every game that has the thing behind them.** `createToolsOverlay` put the panels on screen in 4.1.0 and left every consumer to write the same two bridges, which is the drift this repository opens by describing, one layer in.\n\n**`entitiesInspectable(world, types)` turns an entity world into an `InspectableWorld`.** The inspector addresses a component by name, because a name is what a row carries; a world addresses it by the type object, because that is what indexes its stores. Bridging them is seven forwarding methods and a lookup. **A name with no type behind it does nothing rather than guessing**, so a row built against a stale schema cannot write a field into a component the world does not have and report success, which is a silent loss of an edit somebody just made and watched apply.\n\n**`createSessionRecorder`, `observeSession` and `sessionReadout` turn a lockstep session into a `NetworkReadout`.** The watching is the half worth writing once: `session.desync` is **latched rather than an event**, so it keeps answering with the same disagreement on every frame until the next one arrives, and a recorder that appended what it read would turn one divergence into sixty a second and bury the tick somebody is looking for under copies of itself. `snapshotBytes` is the caller's, because `RewindLoop` is generic over the state it snapshots and cannot know the size of one; a caller passing zero is saying it has not measured.\n\n**Both are typed structurally rather than imported**, the arrangement `@driftengine/drft` already has with the DTEX types `@driftengine/texture` satisfies. So this package gains no dependency, the release is the same ninety five places it was, and a consumer whose state is not an entity world at all can still satisfy the shape.\n\n**5,391 bytes gzipped, from 5,105, and 286 of that is these two.** Named in the size fixture in the same commit, which is the whole point of the paragraph the last release added to that file."
+      },
+      {
+        "kind": "fixed",
+        "short": "The city scene fits the device it is on. A phone binds 128 MiB and the published reach asked for 145, so every handheld got a blank frame and a refusal in a console nobody had open.",
+        "text": "**Reported from a Galaxy S23 Ultra, on the published site: \"A city at dusk\" was a blank frame.** The scene asked for **152,314,560 bytes** as one storage binding and the device binds **134,217,728**. That is 128 MiB, the WebGPU default, and it is what most handhelds offer against the several gigabytes a desktop adapter does.\n\n**Nothing was misconfigured.** `select.ts` already asks the adapter for its ceiling on `maxStorageBufferBindingSize` rather than taking the default, so there was nothing left to raise: the city was simply larger than the part could hold. The refusal was correct, it named the number, and it reached a console rather than a person.\n\n**The scene sizes itself to the device now.** `reachForCeiling` steps down a ladder of reaches until the vertex buffer fits inside four fifths of what the adapter reports, leaving room for the pipeline's other storage bindings. An S23 Ultra gets a reach of 450 metres at 71% of its limit; a desktop adapter keeps the published 900. A smaller reach asked for with `?reach=` is a decision and is never raised to fill the room available.\n\n**The budget could not have fixed this.** The scene ignored the one it was handed, and honouring it would not have helped: a demos page passes `full` to every device and only a `?budget=` in the address says otherwise, so a phone never asked for less. Sizing against the limit the device reports needs no coordination with whoever mounts the scene.\n\n**`VERTEX_FLOATS` is exported for it.** A `StreamCapacity` is counts and what a device refuses is bytes, so whether a capacity fits is `vertices * VERTEX_FLOATS * 4` against the binding ceiling. Without it a consumer either hard-codes the stride or finds out by being refused, which is what this scene did on every phone."
+      }
+    ]
+  },
   {
     "version": "4.1.0",
     "date": "2026-09-20",

package/dist/index.d.ts

@@ -73,7 +73,7 @@ export { OcclusionBuffer } from './render/occlusion.ts';
 export type { ComputeContext, ComputeDefinition, ComputeDevice, ComputeHandle, } from './render/compute.ts';
 export { createRenderer } from './render/backend/createRenderer.ts';
 export type { CreatedRenderer, CreateRendererOptions, RenderPipeline, } from './render/backend/createRenderer.ts';
-export { GPU_DRIVEN_LISTS, GpuDrivenPass, MATERIAL_FLOATS, } from './render/backend/webgpu/gpuDrivenPass.ts';
+export { GPU_DRIVEN_LISTS, GpuDrivenPass, MATERIAL_FLOATS, VERTEX_FLOATS, } from './render/backend/webgpu/gpuDrivenPass.ts';
 export type { GpuDrivenList, GpuDrivenMaterial, GpuDrivenShadowOptions, GpuDrivenView, } from './render/backend/webgpu/gpuDrivenPass.ts';
 export { atmosphereFog, createFogTarget } from './render/fog.ts';
 export type { FogOptions, FogTarget } from './render/fog.ts';

package/dist/index.js

@@ -105,7 +105,15 @@ export { createRenderer } from './render/backend/createRenderer.js';
  * It draws vertex colour, one directional term, a hemispheric ambient and an emissive add — not
  * the standard material. `DRAFT_SCENES`, never `SCENES`, until it draws the six published ones.
  */
-export { GPU_DRIVEN_LISTS, GpuDrivenPass, MATERIAL_FLOATS, } from './render/backend/webgpu/gpuDrivenPass.js';
+export { GPU_DRIVEN_LISTS, GpuDrivenPass, MATERIAL_FLOATS, 
+/*
+ * **The vertex stride, because a consumer sizing a streaming scene has to know it.** A
+ * `StreamCapacity` is counts, and what a device refuses is bytes: the pipeline binds the whole
+ * vertex buffer as one storage binding, so whether a capacity fits is `vertices * VERTEX_FLOATS
+ * * 4` against `maxStorageBufferBindingSize`. Without this a consumer either hard-codes 48 or
+ * finds out by being refused, and the published city scene did the second on every phone.
+ */
+VERTEX_FLOATS, } from './render/backend/webgpu/gpuDrivenPass.js';
 /*
  * **One environment, one haze, on both pipelines.** `GpuDrivenView.fog` is the medium the forward
  * path binds, and a consumer drawing both in one frame fills it from `atmosphereFog` rather than

package/dist/render/backend/webgpu/gpuDrivenPass.d.ts

@@ -613,6 +613,18 @@ export declare class GpuDrivenPass implements PassDefinition {
      * origin so nothing ever said so. `StreamingScene` computes them when a mesh is placed.
      */
     private buildBuffers;
+    /**
+     * Close the two scopes the blend pipeline was built in, and disown it where the device refused.
+     *
+     * **Asynchronous because a pipeline failure is.** Nothing can be known at the call that creates
+     * it, so the first frames draw no transparency and then either it arrives or it never does. That
+     * is the honest order: a pane missing for two frames is invisible, and a frame missing entirely
+     * is what this exists to prevent.
+     *
+     * The warning is once, in the words the device used, because the whole difficulty of the report
+     * this came from was five errors that were all the same one.
+     */
+    private watchBlendPipeline;
     private buildPipelines;
     /**
      * The groups that name `history` and `drawn`, rebuilt when the two swap.

package/dist/render/backend/webgpu/gpuDrivenPass.js

@@ -941,6 +941,29 @@ export class GpuDrivenPass {
         this.zeroHistory = this.empty(device, 'history zero', count * 4);
         this.historySink = this.empty(device, 'history sink', count * 4);
     }
+    /**
+     * Close the two scopes the blend pipeline was built in, and disown it where the device refused.
+     *
+     * **Asynchronous because a pipeline failure is.** Nothing can be known at the call that creates
+     * it, so the first frames draw no transparency and then either it arrives or it never does. That
+     * is the honest order: a pane missing for two frames is invisible, and a frame missing entirely
+     * is what this exists to prevent.
+     *
+     * The warning is once, in the words the device used, because the whole difficulty of the report
+     * this came from was five errors that were all the same one.
+     */
+    watchBlendPipeline(device) {
+        const refused = (error, scope) => {
+            if (error === null || this.blendPipeline === null)
+                return;
+            this.blendPipeline = null;
+            this.blendRasterGroup = null;
+            console.warn(`[driftengine] this device refused the gpu-driven blend pipeline (${scope}), so the ` +
+                `transparent pass is off and everything opaque still draws: ${error.message}`);
+        };
+        void device.popErrorScope().then((error) => refused(error, 'internal'));
+        void device.popErrorScope().then((error) => refused(error, 'validation'));
+    }
     buildPipelines(device, format, samples) {
         const compute = (label, code) => device.createComputePipeline({
             label: `gpu-driven ${label}`,
@@ -1045,6 +1068,23 @@ export class GpuDrivenPass {
          * hide. The opaque raster culls back faces, where a closed hull's far side is a wasted draw.
          */
         const blend = device.createShaderModule({ label: 'blend raster', code: BLEND_RASTER_WGSL });
+        /*
+         * **Built inside error scopes, because a driver that refuses this must not take the frame.**
+         *
+         * Reported from a Galaxy S23 Ultra: `CreateGraphicsPipelines failed with VK_ERROR_UNKNOWN`
+         * for this pipeline, and then four more errors that were all the same one. `createRenderPipeline`
+         * does not throw where a driver refuses — it hands back an *invalid* pipeline and reports
+         * asynchronously — so the code that followed built a bind group from its layout, set it on a
+         * pass, and submitted a command buffer, each of which is invalid because the one before it was.
+         * The city drew **nothing**, on a device that could have drawn all of it but the glass.
+         *
+         * So the handle is disowned where the device refused it and the transparent pass skips itself.
+         * Both scopes, because a shader a driver cannot compile is reported as internal on some
+         * backends and as validation on others, and this is exactly the case where guessing which
+         * costs the whole frame.
+         */
+        device.pushErrorScope('validation');
+        device.pushErrorScope('internal');
         this.blendPipeline = device.createRenderPipeline({
             label: 'gpu-driven blend',
             layout: 'auto',
@@ -1077,6 +1117,7 @@ export class GpuDrivenPass {
                 depthCompare: DEPTH_COMPARE,
             },
         });
+        this.watchBlendPipeline(device);
         /*
          * **Premultiplied over, where `renderer.ts`'s composite is a lerp**, and `blendRaster.wgsl.ts`
          * carries why: this pipeline's colour target has a coverage mask in its alpha, which the blit
@@ -1585,30 +1626,42 @@ export class GpuDrivenPass {
             ],
         });
         /* Everything the transparent raster reads: the same scene, the same frame, its own list. */
-        this.blendRasterGroup = device.createBindGroup({
-            layout: this.blendPipeline.getBindGroupLayout(0),
-            entries: [
-                { binding: 0, resource: { buffer: this.viewProjBuffer } },
-                { binding: 1, resource: { buffer: this.blendList } },
-                { binding: 2, resource: { buffer: this.clusterMeta } },
-                { binding: 3, resource: { buffer: this.indices } },
-                { binding: 4, resource: { buffer: this.vertices } },
-                { binding: 5, resource: { buffer: this.transformBuffer } },
-                { binding: 6, resource: { buffer: this.materialOf } },
-                { binding: 7, resource: { buffer: this.materialTable } },
-                { binding: 8, resource: { buffer: this.frameBuffer } },
-                {
-                    binding: 9,
-                    resource: this.environmentView ?? this.emptyEnvironmentView,
-                },
-                { binding: 10, resource: this.environmentSampler ?? this.emptySampler },
-                { binding: 11, resource: this.latentsView },
-                { binding: 12, resource: this.latentClamp },
-                { binding: 13, resource: this.latentRepeat },
-                { binding: 14, resource: { buffer: this.decodeNodes } },
-                { binding: 15, resource: { buffer: this.decodeWeights } },
-            ],
-        });
+        /*
+         * Nothing to bind against where the device refused the pipeline, and the resolve below still
+         * wants building — it is a different pipeline and this one's absence is not its problem. An
+         * early return here would have taken it with us, which is the same shape of mistake as the
+         * cascade this guard exists to stop.
+         */
+        this.blendRasterGroup =
+            this.blendPipeline === null
+                ? null
+                : device.createBindGroup({
+                    layout: this.blendPipeline.getBindGroupLayout(0),
+                    entries: [
+                        { binding: 0, resource: { buffer: this.viewProjBuffer } },
+                        { binding: 1, resource: { buffer: this.blendList } },
+                        { binding: 2, resource: { buffer: this.clusterMeta } },
+                        { binding: 3, resource: { buffer: this.indices } },
+                        { binding: 4, resource: { buffer: this.vertices } },
+                        { binding: 5, resource: { buffer: this.transformBuffer } },
+                        { binding: 6, resource: { buffer: this.materialOf } },
+                        { binding: 7, resource: { buffer: this.materialTable } },
+                        { binding: 8, resource: { buffer: this.frameBuffer } },
+                        {
+                            binding: 9,
+                            resource: this.environmentView ?? this.emptyEnvironmentView,
+                        },
+                        {
+                            binding: 10,
+                            resource: this.environmentSampler ?? this.emptySampler,
+                        },
+                        { binding: 11, resource: this.latentsView },
+                        { binding: 12, resource: this.latentClamp },
+                        { binding: 13, resource: this.latentRepeat },
+                        { binding: 14, resource: { buffer: this.decodeNodes } },
+                        { binding: 15, resource: { buffer: this.decodeWeights } },
+                    ],
+                });
         this.blendResolveGroup = device.createBindGroup({
             layout: this.blendResolvePipeline.getBindGroupLayout(0),
             entries: [
@@ -2028,6 +2081,13 @@ export class GpuDrivenPass {
                 return;
             }
             case 'blendDraw': {
+                /*
+                 * **Skipped where the device refused the pipeline, rather than drawn with an invalid one.**
+                 * Everything opaque has already been drawn by the time this runs, so what is lost is the
+                 * glass and not the city. See `watchBlendPipeline`.
+                 */
+                if (this.blendPipeline === null || this.blendRasterGroup === null)
+                    return;
                 const pass = encoder.beginRenderPass({
                     label: 'gpu-driven blend draw',
                     colorAttachments: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/core",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "description": "DriftEngine reusable browser 3D runtime",
   "license": "Apache-2.0",
   "type": "module",
@@ -29,8 +29,8 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@driftengine/drft": "4.1.0",
-    "@driftengine/physics": "4.1.0",
+    "@driftengine/drft": "4.1.2",
+    "@driftengine/physics": "4.1.2",
     "gl-matrix": "^3.4.3"
   },
   "author": "Drift Technologies",
@@ -63,8 +63,8 @@
     "prepack": "node ../../scripts/build.mjs @driftengine/core"
   },
   "devDependencies": {
-    "@driftengine/nav": "4.1.0",
-    "@driftengine/network": "4.1.0",
-    "@driftengine/texture": "4.1.0"
+    "@driftengine/nav": "4.1.2",
+    "@driftengine/network": "4.1.2",
+    "@driftengine/texture": "4.1.2"
   }
 }

package/src/index.ts

@@ -238,6 +238,14 @@ export {
   GPU_DRIVEN_LISTS,
   GpuDrivenPass,
   MATERIAL_FLOATS,
+  /*
+   * **The vertex stride, because a consumer sizing a streaming scene has to know it.** A
+   * `StreamCapacity` is counts, and what a device refuses is bytes: the pipeline binds the whole
+   * vertex buffer as one storage binding, so whether a capacity fits is `vertices * VERTEX_FLOATS
+   * * 4` against `maxStorageBufferBindingSize`. Without this a consumer either hard-codes 48 or
+   * finds out by being refused, and the published city scene did the second on every phone.
+   */
+  VERTEX_FLOATS,
 } from './render/backend/webgpu/gpuDrivenPass.ts';
 export type {
   GpuDrivenList,

package/src/render/backend/webgpu/gpuDrivenPass.ts

@@ -1299,6 +1299,31 @@ export class GpuDrivenPass implements PassDefinition {
     this.historySink = this.empty(device, 'history sink', count * 4);
   }
 
+  /**
+   * Close the two scopes the blend pipeline was built in, and disown it where the device refused.
+   *
+   * **Asynchronous because a pipeline failure is.** Nothing can be known at the call that creates
+   * it, so the first frames draw no transparency and then either it arrives or it never does. That
+   * is the honest order: a pane missing for two frames is invisible, and a frame missing entirely
+   * is what this exists to prevent.
+   *
+   * The warning is once, in the words the device used, because the whole difficulty of the report
+   * this came from was five errors that were all the same one.
+   */
+  private watchBlendPipeline(device: GPUDevice): void {
+    const refused = (error: GPUError | null, scope: string): void => {
+      if (error === null || this.blendPipeline === null) return;
+      this.blendPipeline = null;
+      this.blendRasterGroup = null;
+      console.warn(
+        `[driftengine] this device refused the gpu-driven blend pipeline (${scope}), so the ` +
+          `transparent pass is off and everything opaque still draws: ${error.message}`,
+      );
+    };
+    void device.popErrorScope().then((error) => refused(error, 'internal'));
+    void device.popErrorScope().then((error) => refused(error, 'validation'));
+  }
+
   private buildPipelines(device: GPUDevice, format: GPUTextureFormat, samples: number): void {
     const compute = (label: string, code: string): GPUComputePipeline =>
       device.createComputePipeline({
@@ -1409,6 +1434,23 @@ export class GpuDrivenPass implements PassDefinition {
      * hide. The opaque raster culls back faces, where a closed hull's far side is a wasted draw.
      */
     const blend = device.createShaderModule({ label: 'blend raster', code: BLEND_RASTER_WGSL });
+    /*
+     * **Built inside error scopes, because a driver that refuses this must not take the frame.**
+     *
+     * Reported from a Galaxy S23 Ultra: `CreateGraphicsPipelines failed with VK_ERROR_UNKNOWN`
+     * for this pipeline, and then four more errors that were all the same one. `createRenderPipeline`
+     * does not throw where a driver refuses — it hands back an *invalid* pipeline and reports
+     * asynchronously — so the code that followed built a bind group from its layout, set it on a
+     * pass, and submitted a command buffer, each of which is invalid because the one before it was.
+     * The city drew **nothing**, on a device that could have drawn all of it but the glass.
+     *
+     * So the handle is disowned where the device refused it and the transparent pass skips itself.
+     * Both scopes, because a shader a driver cannot compile is reported as internal on some
+     * backends and as validation on others, and this is exactly the case where guessing which
+     * costs the whole frame.
+     */
+    device.pushErrorScope('validation');
+    device.pushErrorScope('internal');
     this.blendPipeline = device.createRenderPipeline({
       label: 'gpu-driven blend',
       layout: 'auto',
@@ -1441,6 +1483,7 @@ export class GpuDrivenPass implements PassDefinition {
         depthCompare: DEPTH_COMPARE,
       },
     });
+    this.watchBlendPipeline(device);
 
     /*
      * **Premultiplied over, where `renderer.ts`'s composite is a lerp**, and `blendRaster.wgsl.ts`
@@ -2015,30 +2058,42 @@ export class GpuDrivenPass implements PassDefinition {
     });
 
     /* Everything the transparent raster reads: the same scene, the same frame, its own list. */
-    this.blendRasterGroup = device.createBindGroup({
-      layout: (this.blendPipeline as GPURenderPipeline).getBindGroupLayout(0),
-      entries: [
-        { binding: 0, resource: { buffer: this.viewProjBuffer as GPUBuffer } },
-        { binding: 1, resource: { buffer: this.blendList as GPUBuffer } },
-        { binding: 2, resource: { buffer: this.clusterMeta as GPUBuffer } },
-        { binding: 3, resource: { buffer: this.indices as GPUBuffer } },
-        { binding: 4, resource: { buffer: this.vertices as GPUBuffer } },
-        { binding: 5, resource: { buffer: this.transformBuffer as GPUBuffer } },
-        { binding: 6, resource: { buffer: this.materialOf as GPUBuffer } },
-        { binding: 7, resource: { buffer: this.materialTable as GPUBuffer } },
-        { binding: 8, resource: { buffer: this.frameBuffer as GPUBuffer } },
-        {
-          binding: 9,
-          resource: this.environmentView ?? (this.emptyEnvironmentView as GPUTextureView),
-        },
-        { binding: 10, resource: this.environmentSampler ?? (this.emptySampler as GPUSampler) },
-        { binding: 11, resource: this.latentsView as GPUTextureView },
-        { binding: 12, resource: this.latentClamp as GPUSampler },
-        { binding: 13, resource: this.latentRepeat as GPUSampler },
-        { binding: 14, resource: { buffer: this.decodeNodes as GPUBuffer } },
-        { binding: 15, resource: { buffer: this.decodeWeights as GPUBuffer } },
-      ],
-    });
+    /*
+     * Nothing to bind against where the device refused the pipeline, and the resolve below still
+     * wants building — it is a different pipeline and this one's absence is not its problem. An
+     * early return here would have taken it with us, which is the same shape of mistake as the
+     * cascade this guard exists to stop.
+     */
+    this.blendRasterGroup =
+      this.blendPipeline === null
+        ? null
+        : device.createBindGroup({
+            layout: this.blendPipeline.getBindGroupLayout(0),
+            entries: [
+              { binding: 0, resource: { buffer: this.viewProjBuffer as GPUBuffer } },
+              { binding: 1, resource: { buffer: this.blendList as GPUBuffer } },
+              { binding: 2, resource: { buffer: this.clusterMeta as GPUBuffer } },
+              { binding: 3, resource: { buffer: this.indices as GPUBuffer } },
+              { binding: 4, resource: { buffer: this.vertices as GPUBuffer } },
+              { binding: 5, resource: { buffer: this.transformBuffer as GPUBuffer } },
+              { binding: 6, resource: { buffer: this.materialOf as GPUBuffer } },
+              { binding: 7, resource: { buffer: this.materialTable as GPUBuffer } },
+              { binding: 8, resource: { buffer: this.frameBuffer as GPUBuffer } },
+              {
+                binding: 9,
+                resource: this.environmentView ?? (this.emptyEnvironmentView as GPUTextureView),
+              },
+              {
+                binding: 10,
+                resource: this.environmentSampler ?? (this.emptySampler as GPUSampler),
+              },
+              { binding: 11, resource: this.latentsView as GPUTextureView },
+              { binding: 12, resource: this.latentClamp as GPUSampler },
+              { binding: 13, resource: this.latentRepeat as GPUSampler },
+              { binding: 14, resource: { buffer: this.decodeNodes as GPUBuffer } },
+              { binding: 15, resource: { buffer: this.decodeWeights as GPUBuffer } },
+            ],
+          });
     this.blendResolveGroup = device.createBindGroup({
       layout: (this.blendResolvePipeline as GPURenderPipeline).getBindGroupLayout(0),
       entries: [
@@ -2519,6 +2574,12 @@ export class GpuDrivenPass implements PassDefinition {
         return;
       }
       case 'blendDraw': {
+        /*
+         * **Skipped where the device refused the pipeline, rather than drawn with an invalid one.**
+         * Everything opaque has already been drawn by the time this runs, so what is lost is the
+         * glass and not the city. See `watchBlendPipeline`.
+         */
+        if (this.blendPipeline === null || this.blendRasterGroup === null) return;
         const pass = encoder.beginRenderPass({
           label: 'gpu-driven blend draw',
           colorAttachments: [
@@ -2546,8 +2607,8 @@ export class GpuDrivenPass implements PassDefinition {
           },
           timestampWrites: this.writesFor('blendDraw'),
         });
-        pass.setPipeline(this.blendPipeline as GPURenderPipeline);
-        pass.setBindGroup(0, this.blendRasterGroup as GPUBindGroup);
+        pass.setPipeline(this.blendPipeline);
+        pass.setBindGroup(0, this.blendRasterGroup);
         pass.setViewport(0, 0, this.width, this.height, 0, 1);
         pass.drawIndirect(this.blendArgs as GPUBuffer, 0);
         pass.end();