@carbonenginejs/runtime 0.1.0-alpha.0 → 0.1.0-alpha.2

package/dist/trinityal/webgpu/CjsWebgpuRenderContextAL.js

@@ -1,93 +1,25 @@
+import { applyDecs2311 as _applyDecs2311 } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { impl, CjsSchema } from '#schema';
+import { Tr2ResourceSetAL } from '../Tr2ResourceSetAL/Tr2ResourceSetAL.js';
 import { Topology, PixelFormat, Tr2LoadAction, Tr2StoreAction, ShaderType, UpscalingResult, UpscalingSetting, UpscalingTechnique } from '#consts/render-context';
 import { Tr2DrawUPHelper, Failed, Tr2VertexLayoutALStub, Tr2ConstantUsageAL, ALResult, Tr2ColorAttachment, Tr2DepthAttachment, resolveBindingPlan } from '#trinityal';
-import { CjsWebgpuWorkQueue } from './core/workQueue.js';
+import { CjsWebgpuWorkQueue } from './core/CjsWebgpuWorkQueue.js';
 import { CjsWebgpuBufferAL } from './CjsWebgpuBufferAL.js';
 import { CjsWebgpuConstantBufferAL } from './CjsWebgpuConstantBufferAL.js';
 import { CjsWebgpuSamplerStateAL } from './CjsWebgpuSamplerStateAL.js';
 import { CjsWebgpuResourceSetAL } from './CjsWebgpuResourceSetAL.js';
 import { CjsWebgpuTextureAL } from './CjsWebgpuTextureAL.js';
-import { CjsWebgpuConstantArena } from './core/constantArena.js';
-import { CanonicalKey } from './core/pipelineCache.js';
+import { CjsWebgpuConstantArena } from './core/CjsWebgpuConstantArena.js';
+import { CanonicalKey } from './core/CjsWebgpuPipelineCache.js';
 import { TOPOLOGIES } from './core/topology.js';
-import { SamplerDescriptionKey } from '../Tr2SamplerDescription.js';
+import { SamplerDescriptionKey } from '../Tr2HalHelperStructures/Tr2SamplerDescription.js';
 import { CjsWebgpuCapsAL } from './CjsWebgpuCapsAL.js';
-import { CjsWebgpuPsoDescription } from './core/psoDescription.js';
-import { CjsWebgpuShaderAL, CjsWebgpuShaderProgramAL, WEBGPU_ENTRY_POINT } from './CjsWebgpuShaderAL.js';
+import { CjsWebgpuPsoDescription } from './core/CjsWebgpuPsoDescription.js';
+import { CjsWebgpuShaderAL, WEBGPU_ENTRY_POINT } from './CjsWebgpuShaderAL.js';
+import { CjsWebgpuShaderProgramAL } from './CjsWebgpuShaderProgramAL.js';
 import { WebgpuVertexBufferLayout } from './core/vertexFormat.js';
 
-// Source: trinity/trinityal/metal/Tr2RenderContextMetal.h
-// Source: trinity/trinityal/metal/Tr2RenderContextMetal.mm
-// Source: trinity/trinityal/stub/Tr2RenderContextStub.h
-//
-// The WebGPU backend behind Carbon's abstraction layer.
-//
-// WHAT THIS REPLACED. `Tr2RenderContext` used to RECORD what Trinity asked for
-// into an intent list, which `framePlan.js` partitioned and `frameExecutor.js`
-// encoded. That mechanism had no Carbon counterpart - Carbon gives the same job
-// to the abstraction layer, and a backend is simply called - and it is now
-// deleted, along with all three of those files (runtime `1e881dec`).
-//
-// THE DIVISION OF LABOUR IS CARBON'S. `Tr2RenderContextAL` (metal) holds the
-// bound state and validates; `MetalWorkQueue` owns the command buffer and the
-// encoder lifetime. `DrawIndexedInstanced` there checks its index buffer,
-// converts a primitive count to a vertex count, then calls the work queue,
-// whose draw opens a render encoder if none is current
-// (`Tr2RenderContextMetal.mm:414-436`, `MetalWorkQueue.mm:2922-2945`). This
-// keeps that split, so `CjsWebgpuWorkQueue` is the only thing that knows when a
-// pass begins.
-//
-// DEVICE-FREE, AS CARBON'S STUB IS. Every verb here is argument validation,
-// state, and delegation - none of it needs a GPU, and Carbon ships a whole
-// backend (`TrinityAL_stub`) on that basis. The device arrives when the work
-// queue's recorded transitions are applied to a real command encoder.
-//
-// SCOPE. The verbs `Tr2RenderContext` forwards to a backend: the geometry and
-// draw path Carbon's `SubmitGeometry` touches (`Tr2RenderContext.cpp:83-103`),
-// the render-target and depth-stencil families with their per-slot stacks, the
-// viewport, clear, compute and present. That is what installing this backend
-// requires, because the context prefers the AL per verb and a missing one is a
-// crash rather than a fallback.
-//
-// NOT HERE YET: texture creation, copies and mip generation. Absent rather than
-// faked. Buffer creation IS here (`CreateBuffer`), because a Trinity class that
-// fills a buffer per frame cannot pick its own backend.
-//
-// WHAT CARBON'S METAL BACKEND HAS THAT THIS DOES NOT, AND WHY.
-//
-// The parity check compares this file against the donors it cites, which
-// includes all of metal - so Metal-only members are reported against a backend
-// that has no reason to carry them. These are decisions, not a queue:
-//
-// - `BeginParallelEncoding`/`EndParallelEncoding`/`ForkContext` spread batch
-//   encoding across threads. There is one thread here, and `Tr2RenderContext`
-//   already records the same omission for the same reason.
-// - `BufferRewritten` notifies the context that a buffer allocation was RENAMED
-//   under it. WebGPU cannot rename: `queue.writeBuffer` is ordered on the queue,
-//   which gives the guarantee renaming buys without renaming, and
-//   `CjsWebgpuBufferAL`'s head comment argues that at length.
-// - `CheckDrawResources` does not validate, which the first version of this
-//   note claimed. Carbon BINDS dummy resources into unfilled slots and installs
-//   the vertex descriptor, on every draw (`Tr2RenderContextMetal.mm:524-541`).
-//   WebGPU has the same requirement and will reject a draw with an unfilled
-//   binding, so the browser is not doing this for us - it is the thing that
-//   rejects us. WE DO IT, under Metal's other name: `EmitRenderEncoderState`
-//   resolves the pipeline, fills unbound slots with dummies and binds the
-//   layout, inside every draw verb. A NAME divergence, not an absence. (Until
-//   2026-09-10 this note said the divergence held "because the dispatcher fills
-//   bindings before the draw reaches here"; there is no dispatcher.)
-// - `ReleaseLater` defers destruction until the GPU has finished reading. A
-//   `GPUBuffer` stays alive as long as a submitted command references it, so
-//   the deferral has nothing to defer.
-// - `UseConstantBuffer` is Metal-only and makes a constant buffer resident on
-//   the COMPUTE encoder (`:1658-1673`); its only callers build the ray-tracing
-//   shader table. No compute dispatches here and there is no ray tracing, so
-//   there is nothing to make resident. (This note used to lump it with
-//   `UploadConstants` and claim "there is no arena", which stopped being true
-//   the day the arena landed. `UploadConstants` IS ported, above.)
-// - `GetMetalContext` and `GetMetalWorkQueue` are Metal's native escape
-//   hatches. Ours are `GetWebgpu` and `GetWorkQueue` - Carbon names these per
-//   backend too, so a WebGPU spelling is the faithful thing, not a divergence.
-
+let _initProto;
 
 /** WebGPU's index format for a Carbon index stride, or null for one it lacks. */
 const INDEX_FORMAT = Object.freeze({
@@ -98,11 +30,11 @@ const INDEX_FORMAT = Object.freeze({
 /** Bind groups kept before the cache is dropped and rebuilt. */
 const MAX_CACHED_BIND_GROUPS = 1024;
 
-/**
- * The `GPUBuffer` behind a bound stream, or null.
- *
- * A stream is whatever Trinity bound: a `Tr2BufferAL` answers; a geometry
- * descriptor - what a mesh batch carries today - does not, and the draw refuses.
+/**
+ * The `GPUBuffer` behind a bound stream, or null.
+ *
+ * A stream is whatever Trinity bound: a `Tr2BufferAL` answers; a geometry
+ * descriptor - what a mesh batch carries today - does not, and the draw refuses.
  */
 function DeviceBufferOf(bound) {
   return bound && typeof bound.GetDeviceBuffer === "function" ? bound.GetDeviceBuffer() : null;
@@ -113,12 +45,12 @@ function fail(message) {
   throw error;
 }
 
-/**
- * How many vertices a primitive count describes, per topology.
- *
- * CARBON'S DRAW VERBS TAKE PRIMITIVES AND ITS BACKENDS DRAW VERTICES, so every
- * one of them converts (`Tr2RenderContextMetal.mm:424`, `ComputeVertexCount`).
- * The conversion depends on the bound topology, which is why the AL holds it.
+/**
+ * How many vertices a primitive count describes, per topology.
+ *
+ * CARBON'S DRAW VERBS TAKE PRIMITIVES AND ITS BACKENDS DRAW VERTICES, so every
+ * one of them converts (`Tr2RenderContextMetal.mm:424`, `ComputeVertexCount`).
+ * The conversion depends on the bound topology, which is why the AL holds it.
  */
 const VERTICES_PER_PRIMITIVE = Object.freeze({
   [Topology.TOP_TRIANGLES]: count => count * 3,
@@ -132,12 +64,12 @@ const VERTICES_PER_PRIMITIVE = Object.freeze({
 /** Carbon's `MAX_RENDER_TARGET`; the bound-target array is fixed width. */
 const MAX_RENDER_TARGET = 8;
 
-/**
- * The Carbon pixel format behind each format a canvas can be configured with.
- *
- * SHORT ON PURPOSE. `GPUCanvasContext.configure` accepts only `bgra8unorm`,
- * `rgba8unorm` and their sRGB view formats, so this is the whole domain rather
- * than a partial table someone should extend later.
+/**
+ * The Carbon pixel format behind each format a canvas can be configured with.
+ *
+ * SHORT ON PURPOSE. `GPUCanvasContext.configure` accepts only `bgra8unorm`,
+ * `rgba8unorm` and their sRGB view formats, so this is the whole domain rather
+ * than a partial table someone should extend later.
  */
 const CANVAS_PIXEL_FORMAT = Object.freeze({
   "bgra8unorm": PixelFormat.PIXEL_FORMAT_B8G8R8A8_UNORM,
@@ -146,29 +78,32 @@ const CANVAS_PIXEL_FORMAT = Object.freeze({
   "rgba8unorm-srgb": PixelFormat.PIXEL_FORMAT_R8G8B8A8_UNORM_SRGB
 });
 
-/**
- * The primary render context, Carbon's process-wide one.
- *
- * A MODULE-LEVEL BINDING, matching the stub, because Carbon's is a static on
- * the class and a JavaScript static field would be per-subclass. There is one
- * primary context per process in Carbon and there is one here.
+/**
+ * The primary render context, Carbon's process-wide one.
+ *
+ * A MODULE-LEVEL BINDING, matching the stub, because Carbon's is a static on
+ * the class and a JavaScript static field would be per-subclass. There is one
+ * primary context per process in Carbon and there is one here.
  */
 let primaryRenderContext = null;
 
-/**
- * How many constant-buffer registers a stage has.
- *
- * Carbon's Metal backend fixes this at 20 (`METAL_CONST_BUFFER_COUNT`,
- * `MetalWorkQueue.h:39`) and rejects anything past it. Kept at Carbon's number
- * rather than a WebGPU limit: this bounds the REGISTER INDEX an effect declares,
- * which the shader compiler already fixed, not the bind-group slot count.
+/**
+ * How many constant-buffer registers a stage has.
+ *
+ * Carbon's Metal backend fixes this at 20 (`METAL_CONST_BUFFER_COUNT`,
+ * `MetalWorkQueue.h:39`) and rejects anything past it. Kept at Carbon's number
+ * rather than a WebGPU limit: this bounds the REGISTER INDEX an effect declares,
+ * which the shader compiler already fixed, not the bind-group slot count.
  */
 const CONSTANT_BUFFER_REGISTERS = 20;
 
 /** WebGPU behind the abstraction layer, holding a work queue as Metal does. */
 class CjsWebgpuRenderContextAL {
+  static {
+    [_initProto] = _applyDecs2311(this, [], [[[impl, impl.custom, void 0, impl.reason("JavaScript chooses the AL implementation through this context factory instead of a compile-time platform include. The private allocation branch preserves the native Create result.")], 18, "CreateResourceSet"], [[impl, impl.adapted, void 0, impl.reason("A copied public wrapper retains the shared ownership record while this context binds the WebGPU implementation.")], 18, "SetResourceSet"]]).e;
+  }
   /** m_workQueue */
-  _workQueue = new CjsWebgpuWorkQueue();
+  _workQueue = (_initProto(this), new CjsWebgpuWorkQueue());
 
   /** m_isValid */
   _isValid = false;
@@ -204,23 +139,23 @@ class CjsWebgpuRenderContextAL {
   /** m_dirtyPso */
   _pipelineDirty = true;
 
-  /**
-   * m_drawUPHelper, DX12's name for it; DX11 calls the same thing m_drawUP.
-   *
-   * Owned rather than shared, as every backend owns its own: the ring's slots
-   * are only safe because one context advances one cursor.
+  /**
+   * m_drawUPHelper, DX12's name for it; DX11 calls the same thing m_drawUP.
+   *
+   * Owned rather than shared, as every backend owns its own: the ring's slots
+   * are only safe because one context advances one cursor.
    */
   _drawUP = new Tr2DrawUPHelper();
 
-  /**
-   * m_psoDescription. Carbon's setters accumulate into one of these and mark it
-   * dirty; every draw entry then calls `SetAllState`, which resolves a pipeline
-   * from a cache keyed on the description's hash and binds it
-   * (`Tr2RenderContextDx12.cpp:763-806`, `:810-880`).
-   *
-   * The class was written for this and wired to nothing until 2026-09-09. It is
-   * filled here so the description is always current; RESOLVING it is the next
-   * step, and needs the bound program to carry its effect package.
+  /**
+   * m_psoDescription. Carbon's setters accumulate into one of these and mark it
+   * dirty; every draw entry then calls `SetAllState`, which resolves a pipeline
+   * from a cache keyed on the description's hash and binds it
+   * (`Tr2RenderContextDx12.cpp:763-806`, `:810-880`).
+   *
+   * The class was written for this and wired to nothing until 2026-09-09. It is
+   * filled here so the description is always current; RESOLVING it is the next
+   * step, and needs the bound program to carry its effect package.
    */
   _psoDescription = new CjsWebgpuPsoDescription();
 
@@ -260,10 +195,10 @@ class CjsWebgpuRenderContextAL {
   /** The acquired swap-chain frame, valid only within one scene. */
   _frame = null;
 
-  /**
-   * @param {object} [composition] The device half; omit for the stub backend.
-   * @param {object} [composition.webgpu] A `CjsWebgpuDevice`.
-   * @param {object} [composition.renderTarget] A `CjsWebgpuRenderTarget`.
+  /**
+   * @param {object} [composition] The device half; omit for the stub backend.
+   * @param {object} [composition.webgpu] A `CjsWebgpuDevice`.
+   * @param {object} [composition.renderTarget] A `CjsWebgpuRenderTarget`.
    */
   constructor({
     webgpu = null,
@@ -287,29 +222,29 @@ class CjsWebgpuRenderContextAL {
     return this._webgpu !== null;
   }
 
-  /**
-   * The device this context draws through.
-   *
-   * Carbon's buffer and texture AL types take a `Tr2PrimaryRenderContextAL&` in
-   * `Create` and reach the device through it (`Tr2BufferAL.h:47`), so the
-   * context being the way to the device is Carbon's shape, not a shortcut.
-   *
-   * @returns {object|null} The `CjsWebgpuDevice`, or null before composition.
+  /**
+   * The device this context draws through.
+   *
+   * Carbon's buffer and texture AL types take a `Tr2PrimaryRenderContextAL&` in
+   * `Create` and reach the device through it (`Tr2BufferAL.h:47`), so the
+   * context being the way to the device is Carbon's shape, not a shortcut.
+   *
+   * @returns {object|null} The `CjsWebgpuDevice`, or null before composition.
    */
   GetWebgpu() {
     return this._webgpu;
   }
 
-  /**
-   * Creates a device-backed buffer, this backend's kind of `Tr2BufferAL`.
-   *
-   * The stub context answers the same call with a `Tr2BufferALStub`, which is
-   * how a Trinity class gets the right buffer for the running backend without
-   * importing either - see the note on the stub's `CreateBuffer`.
-   *
-   * @param {object} description A `Tr2BufferDescriptionAL`.
-   * @param {ArrayBufferView|null} [initialData] Initial contents, if any.
-   * @returns {object|null} The created buffer, or null when Create refused.
+  /**
+   * Creates a device-backed buffer, this backend's kind of `Tr2BufferAL`.
+   *
+   * The stub context answers the same call with a `Tr2BufferALStub`, which is
+   * how a Trinity class gets the right buffer for the running backend without
+   * importing either - see the note on the stub's `CreateBuffer`.
+   *
+   * @param {object} description A `Tr2BufferDescriptionAL`.
+   * @param {ArrayBufferView|null} [initialData] Initial contents, if any.
+   * @returns {object|null} The created buffer, or null when Create refused.
    */
   CreateBuffer(description, initialData = null) {
     const buffer = new CjsWebgpuBufferAL();
@@ -317,18 +252,18 @@ class CjsWebgpuRenderContextAL {
     return buffer;
   }
 
-  /**
-   * Creates a vertex layout, this backend's kind of `Tr2VertexLayoutAL`.
-   *
-   * IT HOLDS THE DEFINITION AND NOTHING DEVICE-SIDE, and that is not a stub
-   * standing in for real work. WebGPU has no input-layout object: the vertex
-   * buffer layouts are part of the render pipeline descriptor and are fixed at
-   * pipeline creation, so a layout here can only be the definition a pipeline
-   * will later be built from. That is why `Tr2VertexLayoutALStub` is the right
-   * shape for this backend too rather than a placeholder for a WebGPU one.
-   *
-   * @param {object[]|object} definition The vertex element list or definition.
-   * @returns {object|null} The created layout, or null when Create refused.
+  /**
+   * Creates a vertex layout, this backend's kind of `Tr2VertexLayoutAL`.
+   *
+   * IT HOLDS THE DEFINITION AND NOTHING DEVICE-SIDE, and that is not a stub
+   * standing in for real work. WebGPU has no input-layout object: the vertex
+   * buffer layouts are part of the render pipeline descriptor and are fixed at
+   * pipeline creation, so a layout here can only be the definition a pipeline
+   * will later be built from. That is why `Tr2VertexLayoutALStub` is the right
+   * shape for this backend too rather than a placeholder for a WebGPU one.
+   *
+   * @param {object[]|object} definition The vertex element list or definition.
+   * @returns {object|null} The created layout, or null when Create refused.
    */
   CreateVertexLayout(definition) {
     const layout = new Tr2VertexLayoutALStub();
@@ -336,16 +271,16 @@ class CjsWebgpuRenderContextAL {
     return layout;
   }
 
-  /**
-   * Creates a constant buffer, this backend's kind of `Tr2ConstantBufferAL`.
-   *
-   * See the stub's note: with no size this returns an empty buffer for a
-   * Trinity caller to `Create` later, as Carbon default-constructs its member.
-   *
-   * @param {number} [size] Bytes; zero returns an empty, invalid buffer.
-   * @param {number} [usage] A `Tr2ConstantUsageAL`.
-   * @param {ArrayBufferView|null} [initialData] Initial contents, if any.
-   * @returns {object|null} The buffer, or null when a sized Create refused.
+  /**
+   * Creates a constant buffer, this backend's kind of `Tr2ConstantBufferAL`.
+   *
+   * See the stub's note: with no size this returns an empty buffer for a
+   * Trinity caller to `Create` later, as Carbon default-constructs its member.
+   *
+   * @param {number} [size] Bytes; zero returns an empty, invalid buffer.
+   * @param {number} [usage] A `Tr2ConstantUsageAL`.
+   * @param {ArrayBufferView|null} [initialData] Initial contents, if any.
+   * @returns {object|null} The buffer, or null when a sized Create refused.
    */
   CreateConstantBuffer(size = 0, usage = Tr2ConstantUsageAL.REUSABLE, initialData = null) {
     const buffer = new CjsWebgpuConstantBufferAL();
@@ -353,23 +288,23 @@ class CjsWebgpuRenderContextAL {
     return buffer;
   }
 
-  /**
-   * Carbon's `Tr2SamplerStateALFactory` (`Tr2SamplerStateAL.h:41-43`), keyed on
-   * the description: equal descriptions are one state.
+  /**
+   * Carbon's `Tr2SamplerStateALFactory` (`Tr2SamplerStateAL.h:41-43`), keyed on
+   * the description: equal descriptions are one state.
    */
   _samplerStates = new Map();
 
-  /**
-   * The sampler state for a description, this backend's kind of
-   * `Tr2SamplerStateAL`, created once per distinct description.
-   *
-   * Carbon's `Tr2SamplerStateAL::Create` IS this lookup
-   * (`Tr2SamplerStateAL.cpp:25-28`): the primary context owns the factory and
-   * hands back the shared object, which is why a resource set can compare
-   * sampler states by identity.
-   *
-   * @param {object} description A `Tr2SamplerDescription`, either spelling.
-   * @returns {object|null} The shared state, or null when Create refused.
+  /**
+   * The sampler state for a description, this backend's kind of
+   * `Tr2SamplerStateAL`, created once per distinct description.
+   *
+   * Carbon's `Tr2SamplerStateAL::Create` IS this lookup
+   * (`Tr2SamplerStateAL.cpp:25-28`): the primary context owns the factory and
+   * hands back the shared object, which is why a resource set can compare
+   * sampler states by identity.
+   *
+   * @param {object} description A `Tr2SamplerDescription`, either spelling.
+   * @returns {object|null} The shared state, or null when Create refused.
    */
   CreateSamplerState(description) {
     const key = SamplerDescriptionKey(description);
@@ -382,20 +317,20 @@ class CjsWebgpuRenderContextAL {
     return state;
   }
 
-  /**
-   * Compiles one shader stage into a `GPUShaderModule`.
-   *
-   * THE FIRST CONSTRUCTION OF THESE CLASSES. `CjsWebgpuShaderAL` and
-   * `CjsWebgpuShaderProgramAL` were written for the immediate-draw route and
-   * nothing built one, because the state manager had no way to ask a backend
-   * for a shader. This is that way.
-   *
-   * @param {number} stageType A Carbon `ShaderType`.
-   * @param {ArrayBufferView|string} bytecode WGSL source, as this backend's
-   *   bytecode; see the head comment on `CjsWebgpuShaderAL`.
-   * @param {object|null} signature The reflected signature.
-   * @param {string} [shaderPath] A debug label.
-   * @returns {object|null} The created shader, or null when Create refused.
+  /**
+   * Compiles one shader stage into a `GPUShaderModule`.
+   *
+   * THE FIRST CONSTRUCTION OF THESE CLASSES. `CjsWebgpuShaderAL` and
+   * `CjsWebgpuShaderProgramAL` were written for the immediate-draw route and
+   * nothing built one, because the state manager had no way to ask a backend
+   * for a shader. This is that way.
+   *
+   * @param {number} stageType A Carbon `ShaderType`.
+   * @param {ArrayBufferView|string} bytecode WGSL source, as this backend's
+   *   bytecode; see the head comment on `CjsWebgpuShaderAL`.
+   * @param {object|null} signature The reflected signature.
+   * @param {string} [shaderPath] A debug label.
+   * @returns {object|null} The created shader, or null when Create refused.
    */
   CreateShader(stageType, bytecode, signature, shaderPath = "") {
     const shader = new CjsWebgpuShaderAL();
@@ -403,11 +338,11 @@ class CjsWebgpuRenderContextAL {
     return shader;
   }
 
-  /**
-   * Links compiled stages into a program.
-   *
-   * @param {object[]} shaders The stages to link.
-   * @returns {object|null} The created program, or null when Create refused.
+  /**
+   * Links compiled stages into a program.
+   *
+   * @param {object[]} shaders The stages to link.
+   * @returns {object|null} The created program, or null when Create refused.
    */
   CreateShaderProgram(shaders) {
     const program = new CjsWebgpuShaderProgramAL();
@@ -415,25 +350,25 @@ class CjsWebgpuRenderContextAL {
     return program;
   }
 
-  /**
-   * How many batches this backend has encoded since it was created.
-   *
-   * A HARNESS NEEDS THIS AND A FRAME DOES NOT, which is why it counts batches
-   * rather than reporting them: "did anything draw" is the question a test asks
-   * when the alternative is trusting an empty canvas. Carbon answers it with
-   * `CCP_STATS_INC( batchCount )` for the same reason.
-   *
-   * @returns {number} Batches encoded.
+  /**
+   * How many batches this backend has encoded since it was created.
+   *
+   * A HARNESS NEEDS THIS AND A FRAME DOES NOT, which is why it counts batches
+   * rather than reporting them: "did anything draw" is the question a test asks
+   * when the alternative is trusting an empty canvas. Carbon answers it with
+   * `CCP_STATS_INC( batchCount )` for the same reason.
+   *
+   * @returns {number} Batches encoded.
    */
   GetDrawnBatchCount() {
     return this._drawnBatchCount;
   }
   _drawnBatchCount = 0;
 
-  /**
-   * The work queue this backend records through.
-   *
-   * @returns {CjsWebgpuWorkQueue} The queue.
+  /**
+   * The work queue this backend records through.
+   *
+   * @returns {CjsWebgpuWorkQueue} The queue.
    */
   GetWorkQueue() {
     return this._workQueue;
@@ -442,56 +377,56 @@ class CjsWebgpuRenderContextAL {
   /** m_caps, built once against whatever device this backend was composed with. */
   _caps = null;
 
-  /**
-   * What this backend can do.
-   *
-   * Carbon returns a reference to a member (`Tr2RenderContextMetal.mm:855-858`),
-   * so the object is stable across calls; built lazily here because the device
-   * is a constructor argument and the caps read its limits.
-   *
-   * @returns {CjsWebgpuCapsAL} The capabilities.
+  /**
+   * What this backend can do.
+   *
+   * Carbon returns a reference to a member (`Tr2RenderContextMetal.mm:855-858`),
+   * so the object is stable across calls; built lazily here because the device
+   * is a constructor argument and the caps read its limits.
+   *
+   * @returns {CjsWebgpuCapsAL} The capabilities.
    */
   GetCaps() {
     this._caps ??= new CjsWebgpuCapsAL(this._webgpu);
     return this._caps;
   }
 
-  /**
-   * m_frameNumber. Carbon's Metal backend keeps this on the context behind it
-   * (`Tr2RenderContextMetal.mm:1686-1694`); there is no such object here, so it
-   * lives on the backend, exactly as the stub keeps it.
+  /**
+   * m_frameNumber. Carbon's Metal backend keeps this on the context behind it
+   * (`Tr2RenderContextMetal.mm:1686-1694`); there is no such object here, so it
+   * lives on the backend, exactly as the stub keeps it.
    */
   _frameNumber = 0;
 
-  /**
-   * The frame being recorded now.
-   *
-   * @returns {number} One past the last frame submitted.
+  /**
+   * The frame being recorded now.
+   *
+   * @returns {number} One past the last frame submitted.
    */
   GetRecordingFrameNumber() {
     return this._frameNumber + 1;
   }
 
-  /**
-   * The last frame handed to the device.
-   *
-   * SUBMISSION, NOT COMPLETION. `GPUQueue.submit` returns without waiting, and
-   * the only handle on actual completion is `onSubmittedWorkDone`, a promise -
-   * so a truthful "rendered" count would lag by an unbounded amount and could
-   * not be read synchronously. This counts submitted frames, and a ring buffer
-   * fencing against it is therefore protected by submission order rather than
-   * by GPU completion.
-   *
-   * @returns {number} Frames submitted.
+  /**
+   * The last frame handed to the device.
+   *
+   * SUBMISSION, NOT COMPLETION. `GPUQueue.submit` returns without waiting, and
+   * the only handle on actual completion is `onSubmittedWorkDone`, a promise -
+   * so a truthful "rendered" count would lag by an unbounded amount and could
+   * not be read synchronously. This counts submitted frames, and a ring buffer
+   * fencing against it is therefore protected by submission order rather than
+   * by GPU completion.
+   *
+   * @returns {number} Frames submitted.
    */
   GetRenderedFrameNumber() {
     return this._frameNumber;
   }
 
-  /**
-   * Everything the work queue has reported since the last drain.
-   *
-   * @returns {object[]} Transitions and draws, in order.
+  /**
+   * Everything the work queue has reported since the last drain.
+   *
+   * @returns {object[]} Transitions and draws, in order.
    */
   DrainTransitions() {
     const transitions = this._transitions;
@@ -499,10 +434,10 @@ class CjsWebgpuRenderContextAL {
     return transitions;
   }
 
-  /**
-   * Creates the device. Carbon gates every resource create on this.
-   *
-   * @returns {boolean} True.
+  /**
+   * Creates the device. Carbon gates every resource create on this.
+   *
+   * @returns {boolean} True.
    */
   CreateDevice() {
     this._isValid = true;
@@ -514,10 +449,10 @@ class CjsWebgpuRenderContextAL {
     return this._isValid;
   }
 
-  /**
-   * Opens the frame's command buffer.
-   *
-   * @returns {boolean} True.
+  /**
+   * Opens the frame's command buffer.
+   *
+   * @returns {boolean} True.
    */
   BeginScene() {
     if (!this._isValid) fail("BeginScene before CreateDevice");
@@ -547,12 +482,12 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * The render-pass descriptor for a set of folded attachments.
-   *
-   * `attachments` IS NULL FOR AN UNHINTED PASS, which is most of them: Carbon
-   * applies load and store actions only when a hint is pending and otherwise
-   * leaves the backend's own defaults alone. Ours are the render target's.
+  /**
+   * The render-pass descriptor for a set of folded attachments.
+   *
+   * `attachments` IS NULL FOR AN UNHINTED PASS, which is most of them: Carbon
+   * applies load and store actions only when a hint is pending and otherwise
+   * leaves the backend's own defaults alone. Ours are the render target's.
    */
   _Descriptor(attachments) {
     // First pass of the scene acquires; later passes share the one view.
@@ -565,17 +500,17 @@ class CjsWebgpuRenderContextAL {
     });
   }
 
-  /**
-   * Closes the frame's last pass and submits the command buffer.
-   *
-   * SYNCHRONOUS, AS CARBON'S IS. The first version awaited the dispatcher's
-   * preparation here, because the backend had been handed batches it still had
-   * to turn into pipelines. It is handed verbs now, every draw resolved inside
-   * the verb that issued it, and there is nothing left to wait for: `finish()`
-   * and `queue.submit()` are synchronous calls. A caller that awaits this
-   * still may; awaiting a non-promise costs nothing.
-   *
-   * @returns {boolean} Whether the scene ended cleanly.
+  /**
+   * Closes the frame's last pass and submits the command buffer.
+   *
+   * SYNCHRONOUS, AS CARBON'S IS. The first version awaited the dispatcher's
+   * preparation here, because the backend had been handed batches it still had
+   * to turn into pipelines. It is handed verbs now, every draw resolved inside
+   * the verb that issued it, and there is nothing left to wait for: `finish()`
+   * and `queue.submit()` are synchronous calls. A caller that awaits this
+   * still may; awaiting a non-promise costs nothing.
+   *
+   * @returns {boolean} Whether the scene ended cleanly.
    */
   EndScene() {
     this._Record(this._workQueue.EndFrame());
@@ -610,14 +545,14 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Declares what the next render pass does with its attachments.
-   *
-   * Carbon's two overloads differ only in how many colour attachments they
-   * carry, so they collapse into one variadic list. The depth attachment is
-   * always last.
-   *
-   * @param {...object} attachments `Tr2ColorAttachment`s then a `Tr2DepthAttachment`.
+  /**
+   * Declares what the next render pass does with its attachments.
+   *
+   * Carbon's two overloads differ only in how many colour attachments they
+   * carry, so they collapse into one variadic list. The depth attachment is
+   * always last.
+   *
+   * @param {...object} attachments `Tr2ColorAttachment`s then a `Tr2DepthAttachment`.
    */
   RenderPassHint(...attachments) {
     const depth = attachments.length ? attachments[attachments.length - 1] : null;
@@ -630,18 +565,18 @@ class CjsWebgpuRenderContextAL {
     this._Record(this._workQueue.EndRenderPassHint());
   }
 
-  /**
-   * Binds a colour target at one slot.
-   *
-   * RESETS THE VIEWPORT TO THE NEW TARGET, which Carbon does here in the
-   * backend (`Tr2RenderContextMetal.mm:762-766`) whenever slot zero changes.
-   * Leaving it alone is the defect where a 2048 shadow pass leaves the viewport
-   * at 2048 for the rest of the frame.
-   *
-   * @param {number} slot The slot.
-   * @param {object|null} renderTarget A `Tr2TextureAL`, or null to detach.
-   * @param {number} [slice] The array slice or cube face.
-   * @returns {boolean} True.
+  /**
+   * Binds a colour target at one slot.
+   *
+   * RESETS THE VIEWPORT TO THE NEW TARGET, which Carbon does here in the
+   * backend (`Tr2RenderContextMetal.mm:762-766`) whenever slot zero changes.
+   * Leaving it alone is the defect where a 2048 shadow pass leaves the viewport
+   * at 2048 for the rest of the frame.
+   *
+   * @param {number} slot The slot.
+   * @param {object|null} renderTarget A `Tr2TextureAL`, or null to detach.
+   * @param {number} [slice] The array slice or cube face.
+   * @returns {boolean} True.
    */
   SetRenderTarget(slot, renderTarget, slice = 0) {
     if (slot >= MAX_RENDER_TARGET) return false;
@@ -663,25 +598,25 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * The target bound at one slot.
-   *
-   * @param {number} [slot] The slot.
-   * @returns {object|null} The target.
+  /**
+   * The target bound at one slot.
+   *
+   * @param {number} [slot] The slot.
+   * @returns {object|null} The target.
    */
   GetRenderTarget(slot = 0) {
     return this._boundRenderTargets[slot] ?? null;
   }
 
-  /**
-   * Saves the target bound at one slot.
-   *
-   * ONE STACK PER SLOT, as Carbon has (`m_stackRT[MAX_RENDER_TARGET]`). A single
-   * shared stack pops the most recent push whatever its slot, so pushing slot 0
-   * then slot 1 and popping slot 0 restores the wrong surface.
-   *
-   * @param {number} [slot] The slot.
-   * @returns {boolean} True.
+  /**
+   * Saves the target bound at one slot.
+   *
+   * ONE STACK PER SLOT, as Carbon has (`m_stackRT[MAX_RENDER_TARGET]`). A single
+   * shared stack pops the most recent push whatever its slot, so pushing slot 0
+   * then slot 1 and popping slot 0 restores the wrong surface.
+   *
+   * @param {number} [slot] The slot.
+   * @returns {boolean} True.
    */
   PushRenderTarget(slot = 0) {
     if (slot >= MAX_RENDER_TARGET) return false;
@@ -689,11 +624,11 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Restores the target saved for one slot.
-   *
-   * @param {number} [slot] The slot.
-   * @returns {boolean} Whether anything was saved.
+  /**
+   * Restores the target saved for one slot.
+   *
+   * @param {number} [slot] The slot.
+   * @returns {boolean} Whether anything was saved.
    */
   PopRenderTarget(slot = 0) {
     const stack = this._renderTargetStacks[slot];
@@ -702,21 +637,21 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Depth of one slot's stack.
-   *
-   * @param {number} [slot] The slot.
-   * @returns {number} The depth.
+  /**
+   * Depth of one slot's stack.
+   *
+   * @param {number} [slot] The slot.
+   * @returns {number} The depth.
    */
   GetStackSizeRT(slot = 0) {
     return this._renderTargetStacks[slot]?.length ?? 0;
   }
 
-  /**
-   * Binds the depth-stencil target.
-   *
-   * @param {object|null} depthStencil A `Tr2TextureAL`, or null to detach.
-   * @returns {boolean} True.
+  /**
+   * Binds the depth-stencil target.
+   *
+   * @param {object|null} depthStencil A `Tr2TextureAL`, or null to detach.
+   * @returns {boolean} True.
    */
   SetDepthStencil(depthStencil) {
     this._Record(this._workQueue.SetDepthAttachment(depthStencil ?? null));
@@ -748,11 +683,11 @@ class CjsWebgpuRenderContextAL {
     return this._depthStencilStack.length;
   }
 
-  /**
-   * The size of the target at one slot.
-   *
-   * @param {number} [slot] The slot.
-   * @returns {object} `{ result, width, height }`.
+  /**
+   * The size of the target at one slot.
+   *
+   * @param {number} [slot] The slot.
+   * @returns {object} `{ result, width, height }`.
    */
   GetRenderTargetSize(slot = 0) {
     const target = this._boundRenderTargets[slot];
@@ -768,21 +703,21 @@ class CjsWebgpuRenderContextAL {
     };
   }
 
-  /**
-   * Whether a target can be drawn to.
-   *
-   * @param {object} renderTarget The target.
-   * @returns {boolean} Whether it is usable.
+  /**
+   * Whether a target can be drawn to.
+   *
+   * @param {object} renderTarget The target.
+   * @returns {boolean} Whether it is usable.
    */
   IsRenderTargetValid(renderTarget) {
     return this._isValid && !!renderTarget;
   }
 
-  /**
-   * Sets the viewport following draws use.
-   *
-   * @param {object} viewport `{ x, y, width, height }`.
-   * @returns {boolean} True.
+  /**
+   * Sets the viewport following draws use.
+   *
+   * @param {object} viewport `{ x, y, width, height }`.
+   * @returns {boolean} True.
    */
   SetViewport(viewport) {
     this._viewport = viewport ? {
@@ -798,16 +733,16 @@ class CjsWebgpuRenderContextAL {
     } : null;
   }
 
-  /**
-   * Clears the bound attachments.
-   *
-   * A CLEAR IS A LOAD OPERATION, not a command. WebGPU has no mid-pass clear,
-   * so this ends the current pass and declares the next one's load actions -
-   * which is the same thing `RenderPassHint` does, arrived at from the other
-   * direction. Carbon's Metal backend folds a clear the same way.
-   *
-   * @param {object} [options] `{ color, depth, stencil }` values.
-   * @returns {boolean} True.
+  /**
+   * Clears the bound attachments.
+   *
+   * A CLEAR IS A LOAD OPERATION, not a command. WebGPU has no mid-pass clear,
+   * so this ends the current pass and declares the next one's load actions -
+   * which is the same thing `RenderPassHint` does, arrived at from the other
+   * direction. Carbon's Metal backend folds a clear the same way.
+   *
+   * @param {object} [options] `{ color, depth, stencil }` values.
+   * @returns {boolean} True.
    */
   Clear(options = {}) {
     const attachments = this._workQueue.GetAttachments();
@@ -817,90 +752,90 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Runs a compute dispatch, which may not happen inside a render pass.
-   *
-   * REFUSES, BECAUSE NOTHING DISPATCHES. This reported success and encoded no
-   * command: it set the encoder type and returned true, and there is no
-   * `dispatchWorkgroups` anywhere in this backend. A caller running a cull or
-   * simulate pass was told it had happened, then read a buffer the GPU never
-   * touched - with no validation error, because no command existed to be
-   * rejected. That is the failure `ClearUav` below refuses to allow, one method
-   * over, and it was allowed here for a day.
-   *
-   * Carbon's stub refuses too (`stub/Tr2RenderContextStub.h:171-174`, `E_FAIL`).
-   *
-   * @param {number} [_x] Workgroups.
-   * @param {number} [_y] Workgroups.
-   * @param {number} [_z] Workgroups.
-   * @returns {boolean} False; nothing is dispatched.
+  /**
+   * Runs a compute dispatch, which may not happen inside a render pass.
+   *
+   * REFUSES, BECAUSE NOTHING DISPATCHES. This reported success and encoded no
+   * command: it set the encoder type and returned true, and there is no
+   * `dispatchWorkgroups` anywhere in this backend. A caller running a cull or
+   * simulate pass was told it had happened, then read a buffer the GPU never
+   * touched - with no validation error, because no command existed to be
+   * rejected. That is the failure `ClearUav` below refuses to allow, one method
+   * over, and it was allowed here for a day.
+   *
+   * Carbon's stub refuses too (`stub/Tr2RenderContextStub.h:171-174`, `E_FAIL`).
+   *
+   * @param {number} [_x] Workgroups.
+   * @param {number} [_y] Workgroups.
+   * @param {number} [_z] Workgroups.
+   * @returns {boolean} False; nothing is dispatched.
    */
   RunComputeShader(_x = 1, _y = 1, _z = 1) {
     return false;
   }
 
-  /**
-   * Runs a compute dispatch whose group counts are read from a buffer.
-   *
-   * REFUSES; see `RunComputeShader`. This validated the buffer and then set the
-   * compute encoder type, which is not a dispatch - the same false success, with
-   * an argument check in front of it that made it look like more.
-   *
-   * Carbon's stub refuses too (`stub/Tr2RenderContextStub.h:175-178`).
-   *
-   * @param {object} _effect The compute effect to run.
-   * @param {object} _indirectionBuffer A buffer holding the group counts.
-   * @param {number} [_offsetForArgs] Byte offset to them.
-   * @returns {boolean} False; nothing is dispatched.
+  /**
+   * Runs a compute dispatch whose group counts are read from a buffer.
+   *
+   * REFUSES; see `RunComputeShader`. This validated the buffer and then set the
+   * compute encoder type, which is not a dispatch - the same false success, with
+   * an argument check in front of it that made it look like more.
+   *
+   * Carbon's stub refuses too (`stub/Tr2RenderContextStub.h:175-178`).
+   *
+   * @param {object} _effect The compute effect to run.
+   * @param {object} _indirectionBuffer A buffer holding the group counts.
+   * @param {number} [_offsetForArgs] Byte offset to them.
+   * @returns {boolean} False; nothing is dispatched.
    */
   RunComputeShaderIndirect(_effect, _indirectionBuffer, _offsetForArgs = 0) {
     return false;
   }
 
-  /**
-   * Clears an unordered-access resource.
-   *
-   * REFUSES RATHER THAN PRETENDS. Carbon's Metal backend clears through
-   * `MetalWorkQueue::ClearBuffer`/`ClearTexture`
-   * (`Tr2RenderContextMetal.mm:237-280`); this work queue has neither, and
-   * WebGPU's own equivalents - `clearBuffer` on the command encoder, a
-   * clear-load render pass for a texture - are not wired to it. Reporting
-   * success would leave a caller reading stale contents it believes are zero,
-   * which is exactly the failure a compute pass cannot detect. Carbon's stub
-   * refuses the same way (`Tr2RenderContextALStub.ClearUav`).
-   *
-   * @param {object} _resource The buffer or texture to clear.
-   * @param {number[]} _value The clear value, four components.
-   * @param {boolean} [_clearWithFloat] Whether the value is float or integer.
-   * @returns {boolean} False; the clear is not encoded.
+  /**
+   * Clears an unordered-access resource.
+   *
+   * REFUSES RATHER THAN PRETENDS. Carbon's Metal backend clears through
+   * `MetalWorkQueue::ClearBuffer`/`ClearTexture`
+   * (`Tr2RenderContextMetal.mm:237-280`); this work queue has neither, and
+   * WebGPU's own equivalents - `clearBuffer` on the command encoder, a
+   * clear-load render pass for a texture - are not wired to it. Reporting
+   * success would leave a caller reading stale contents it believes are zero,
+   * which is exactly the failure a compute pass cannot detect. Carbon's stub
+   * refuses the same way (`Tr2RenderContextALStub.ClearUav`).
+   *
+   * @param {object} _resource The buffer or texture to clear.
+   * @param {number[]} _value The clear value, four components.
+   * @param {boolean} [_clearWithFloat] Whether the value is float or integer.
+   * @returns {boolean} False; the clear is not encoded.
    */
   ClearUav(_resource, _value, _clearWithFloat = false) {
     return false;
   }
 
-  /**
-   * Presents the frame.
-   *
-   * The browser presents a configured canvas after the submission that drew
-   * into its current texture, so there is nothing to do beyond ending the
-   * frame's work.
-   *
-   * AWAITS, because `EndScene` on this backend does. Returning its promise
-   * unawaited would hand a caller expecting a boolean something truthy that is
-   * not a result - the frame would still be encoding when presentation was
-   * reported complete.
-   *
-   * @returns {Promise<boolean>} True once the frame is submitted.
+  /**
+   * Presents the frame.
+   *
+   * The browser presents a configured canvas after the submission that drew
+   * into its current texture, so there is nothing to do beyond ending the
+   * frame's work.
+   *
+   * AWAITS, because `EndScene` on this backend does. Returning its promise
+   * unawaited would hand a caller expecting a boolean something truthy that is
+   * not a result - the frame would still be encoding when presentation was
+   * reported complete.
+   *
+   * @returns {Promise<boolean>} True once the frame is submitted.
    */
   async Present() {
     return this.EndScene();
   }
 
-  /**
-   * Sets the primitive topology following draws use.
-   *
-   * @param {number} topology A `Topology` value.
-   * @returns {boolean} Whether the AL knows it.
+  /**
+   * Sets the primitive topology following draws use.
+   *
+   * @param {number} topology A `Topology` value.
+   * @returns {boolean} Whether the AL knows it.
    */
   SetTopology(topology) {
     if (topology >= Topology.TOP_MAX_TOPOLOGY || !VERTICES_PER_PRIMITIVE[topology]) return false;
@@ -910,11 +845,11 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Binds the vertex declaration.
-   *
-   * @param {object} layout A `Tr2VertexLayoutAL`.
-   * @returns {boolean} True.
+  /**
+   * Binds the vertex declaration.
+   *
+   * @param {object} layout A `Tr2VertexLayoutAL`.
+   * @returns {boolean} True.
    */
   SetVertexLayout(layout) {
     if (this._vertexLayout === layout) return true;
@@ -930,14 +865,14 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Binds one vertex stream.
-   *
-   * @param {number} stream The slot.
-   * @param {object} buffer A `Tr2BufferAL`.
-   * @param {number} offset Byte offset.
-   * @param {number} stride Bytes per vertex.
-   * @returns {boolean} True.
+  /**
+   * Binds one vertex stream.
+   *
+   * @param {number} stream The slot.
+   * @param {object} buffer A `Tr2BufferAL`.
+   * @param {number} offset Byte offset.
+   * @param {number} stride Bytes per vertex.
+   * @returns {boolean} True.
    */
   SetStreamSource(stream, buffer, offset, stride) {
     // The stride is part of the pipeline on WebGPU - `arrayStride` lives in the
@@ -953,12 +888,12 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Binds the index buffer.
-   *
-   * @param {object} buffer A `Tr2BufferAL`.
-   * @param {number} [stride] Bytes per index.
-   * @returns {boolean} True.
+  /**
+   * Binds the index buffer.
+   *
+   * @param {object} buffer A `Tr2BufferAL`.
+   * @param {number} [stride] Bytes per index.
+   * @returns {boolean} True.
    */
   SetIndices(buffer, stride = 0) {
     this._indexBuffer = buffer;
@@ -966,11 +901,11 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Binds the shader program following draws run.
-   *
-   * @param {object} shaderProgram A `Tr2ShaderProgramAL`.
-   * @returns {boolean} True.
+  /**
+   * Binds the shader program following draws run.
+   *
+   * @param {object} shaderProgram A `Tr2ShaderProgramAL`.
+   * @returns {boolean} True.
    */
   SetShaderProgram(shaderProgram) {
     if (this._shaderProgram === shaderProgram) return true;
@@ -980,24 +915,24 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Takes the render-state setup a pass authored, with the state manager's
-   * overrides applied.
-   *
-   * Carbon's backends receive a resolved state-PAIR list here and set each pair
-   * on the device (`Tr2EffectStateManager.cpp:753`). WebGPU has no per-state
-   * setter - state is folded into a pipeline at creation - so the setup is held
-   * and projected when a pipeline is resolved, which is also why the projection
-   * needs the depth format only this backend knows.
-   *
-   * THE PROJECTION IS NOT DONE HERE. `Tr2RenderStateSetup.GetWebgpuRecipe`
-   * already does it and the batch resolver already uses it; a second translator
-   * would be the mistake this whole lane exists to undo. This stores the inputs
-   * and marks the pipeline dirty, as Carbon's setters do.
-   *
-   * @param {object} setup A `Tr2RenderStateSetup`.
-   * @param {object} [overrides] The state manager's render-state overrides.
-   * @returns {boolean} Whether a setup was supplied.
+  /**
+   * Takes the render-state setup a pass authored, with the state manager's
+   * overrides applied.
+   *
+   * Carbon's backends receive a resolved state-PAIR list here and set each pair
+   * on the device (`Tr2EffectStateManager.cpp:753`). WebGPU has no per-state
+   * setter - state is folded into a pipeline at creation - so the setup is held
+   * and projected when a pipeline is resolved, which is also why the projection
+   * needs the depth format only this backend knows.
+   *
+   * THE PROJECTION IS NOT DONE HERE. `Tr2RenderStateSetup.GetWebgpuRecipe`
+   * already does it and the batch resolver already uses it; a second translator
+   * would be the mistake this whole lane exists to undo. This stores the inputs
+   * and marks the pipeline dirty, as Carbon's setters do.
+   *
+   * @param {object} setup A `Tr2RenderStateSetup`.
+   * @param {object} [overrides] The state manager's render-state overrides.
+   * @returns {boolean} Whether a setup was supplied.
    */
   SetRenderStates(setup, overrides = null) {
     if (!setup) return false;
@@ -1015,33 +950,33 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * m_renderStates - single states set by name rather than through a setup.
-   *
-   * A DIFFERENT AXIS FROM `overrides`, which is a flags object the PSO
-   * description reads (`core/psoDescription.js:113-114`). These are Carbon's
-   * raw `RenderState` values, which `TriStepSetRenderState` sets one at a time.
+  /**
+   * m_renderStates - single states set by name rather than through a setup.
+   *
+   * A DIFFERENT AXIS FROM `overrides`, which is a flags object the PSO
+   * description reads (`core/psoDescription.js:113-114`). These are Carbon's
+   * raw `RenderState` values, which `TriStepSetRenderState` sets one at a time.
    */
   _renderStates = new Map();
 
-  /**
-   * Sets one render state.
-   *
-   * Carbon's Metal backend stores the value and applies it when the pipeline is
-   * assembled, and says so in a comment above the method: "we'll remove the
-   * actual setting here and just store the values in some state and we'll do a
-   * wholesale setting of state in some combined function just before we draw"
-   * (`Tr2RenderContextMetal.mm:925-928`). This stores.
-   *
-   * THE PSO RESOLVER DOES NOT READ THESE YET. `GetWebgpuRecipe` projects the
-   * setup and the flags, and nothing consumes the single-state map, so a state
-   * set this way is recorded and not yet honoured. Recorded rather than dropped,
-   * because the resolver is where the projection belongs and adding a second
-   * translator here is the mistake this file already carries a warning about.
-   *
-   * @param {number} state A `RenderState` value.
-   * @param {number} value The value to set.
-   * @returns {boolean} True.
+  /**
+   * Sets one render state.
+   *
+   * Carbon's Metal backend stores the value and applies it when the pipeline is
+   * assembled, and says so in a comment above the method: "we'll remove the
+   * actual setting here and just store the values in some state and we'll do a
+   * wholesale setting of state in some combined function just before we draw"
+   * (`Tr2RenderContextMetal.mm:925-928`). This stores.
+   *
+   * THE PSO RESOLVER DOES NOT READ THESE YET. `GetWebgpuRecipe` projects the
+   * setup and the flags, and nothing consumes the single-state map, so a state
+   * set this way is recorded and not yet honoured. Recorded rather than dropped,
+   * because the resolver is where the projection belongs and adding a second
+   * translator here is the mistake this file already carries a warning about.
+   *
+   * @param {number} state A `RenderState` value.
+   * @param {number} value The value to set.
+   * @returns {boolean} True.
    */
   SetRenderState(state, value) {
     const key = state >>> 0;
@@ -1065,14 +1000,14 @@ class CjsWebgpuRenderContextAL {
     return this._pipelineDirty;
   }
 
-  /**
-   * The pipeline description the setters have accumulated.
-   *
-   * Carbon's `m_psoDescription`, and `GetMissing()` on it answers the question
-   * `GetPipelineState` answers by returning null: what this state does not yet
-   * name. Reading it does not resolve anything.
-   *
-   * @returns {CjsWebgpuPsoDescription} The live description.
+  /**
+   * The pipeline description the setters have accumulated.
+   *
+   * Carbon's `m_psoDescription`, and `GetMissing()` on it answers the question
+   * `GetPipelineState` answers by returning null: what this state does not yet
+   * name. Reading it does not resolve anything.
+   *
+   * @returns {CjsWebgpuPsoDescription} The live description.
    */
   GetPsoDescription() {
     this._RefreshAttachmentFormats();
@@ -1082,45 +1017,45 @@ class CjsWebgpuRenderContextAL {
   /** The pipeline the last resolve produced, or null. */
   _pipeline = null;
 
-  /**
-   * Resolved pipelines by description key.
-   *
-   * Carbon keeps this on the DEVICE (`m_ownerDevice->m_pipelineStates`,
-   * `Tr2PrimaryRenderContextDx12.h:319`; Metal's `GetCachedRenderPipelineState`)
-   * so every context shares one. It lives here until `CjsWebgpuDevice` offers a
-   * synchronous cache - its `CjsWebgpuPipelineCache` resolves asynchronously,
-   * and a draw verb cannot await. Cleared with the device resources.
+  /**
+   * Resolved pipelines by description key.
+   *
+   * Carbon keeps this on the DEVICE (`m_ownerDevice->m_pipelineStates`,
+   * `Tr2PrimaryRenderContextDx12.h:319`; Metal's `GetCachedRenderPipelineState`)
+   * so every context shares one. It lives here until `CjsWebgpuDevice` offers a
+   * synchronous cache - its `CjsWebgpuPipelineCache` resolves asynchronously,
+   * and a draw verb cannot await. Cleared with the device resources.
    */
   _pipelines = new Map();
 
-  /**
-   * Why the last `EmitRenderEncoderState` refused, or null when it did not.
-   *
-   * Carbon asserts at these points; a JS frame must not die at a draw, so the
-   * reason is kept where a harness can read it instead.
+  /**
+   * Why the last `EmitRenderEncoderState` refused, or null when it did not.
+   *
+   * Carbon asserts at these points; a JS frame must not die at a draw, so the
+   * reason is kept where a harness can read it instead.
    */
   m_pipelineFailure = null;
 
-  /**
-   * Resolves and binds the pipeline the bound state describes.
-   *
-   * METAL'S `EmitRenderPipelineState` (`MetalWorkQueue.mm:1595-1747`) AND
-   * DX12'S `SetAllState` (`Tr2RenderContextDx12.cpp:810-878`): called from
-   * inside every draw verb, keyed on the description's hash, creating on a miss
-   * and otherwise reusing, and clearing the dirty flag once resolved
-   * (`:870`). Pipeline creation is SYNCHRONOUS here as it is there -
-   * `createRenderPipeline` returns immediately, and the first-use stall it can
-   * carry is the same one `newRenderPipelineStateWithDescriptor` carries.
-   *
-   * The vertex half of the description is built here rather than by
-   * `SetVertexLayout`, because it depends on three bound things at once: the
-   * declaration, the program whose inputs select from it, and the stream
-   * strides (`Tr2RenderContextMetal.mm:524-541`, `MetalWorkQueue.mm:1842-1863`).
-   *
-   * Uncomposed, there is no device and nothing to resolve; the verbs record as
-   * the stub's do.
-   *
-   * @returns {boolean} Whether a pipeline is bound for the next draw.
+  /**
+   * Resolves and binds the pipeline the bound state describes.
+   *
+   * METAL'S `EmitRenderPipelineState` (`MetalWorkQueue.mm:1595-1747`) AND
+   * DX12'S `SetAllState` (`Tr2RenderContextDx12.cpp:810-878`): called from
+   * inside every draw verb, keyed on the description's hash, creating on a miss
+   * and otherwise reusing, and clearing the dirty flag once resolved
+   * (`:870`). Pipeline creation is SYNCHRONOUS here as it is there -
+   * `createRenderPipeline` returns immediately, and the first-use stall it can
+   * carry is the same one `newRenderPipelineStateWithDescriptor` carries.
+   *
+   * The vertex half of the description is built here rather than by
+   * `SetVertexLayout`, because it depends on three bound things at once: the
+   * declaration, the program whose inputs select from it, and the stream
+   * strides (`Tr2RenderContextMetal.mm:524-541`, `MetalWorkQueue.mm:1842-1863`).
+   *
+   * Uncomposed, there is no device and nothing to resolve; the verbs record as
+   * the stub's do.
+   *
+   * @returns {boolean} Whether a pipeline is bound for the next draw.
    */
   EmitRenderPipelineState() {
     if (!this._webgpu) return true;
@@ -1179,23 +1114,23 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Binds everything a draw needs on the encoder: pipeline, then buffers.
-   *
-   * Metal's `EmitRenderEncoderState` (`MetalWorkQueue.mm:1750-1890`), which
-   * the draw verbs call first and skip the draw when it fails. Bindings are
-   * deferred to here rather than set in `SetStreamSource`, as Metal defers
-   * them (`:2570-2598` stores, `:2613-2690` binds).
-   *
-   * WHAT IT CANNOT YET HONOUR, IT REFUSES. A program whose layout declares
-   * bind groups needs a resource set realised into `GPUBindGroup`s, and that
-   * half is not ported; drawing without them is a validation error on the GPU,
-   * so the draw is refused here and says why. A stream whose buffer is not a
-   * device buffer - a mesh batch carries a geometry descriptor today - is
-   * refused the same way.
-   *
-   * @param {boolean} indexed Whether the draw reads the bound index buffer.
-   * @returns {boolean} Whether the encoder is ready to draw.
+  /**
+   * Binds everything a draw needs on the encoder: pipeline, then buffers.
+   *
+   * Metal's `EmitRenderEncoderState` (`MetalWorkQueue.mm:1750-1890`), which
+   * the draw verbs call first and skip the draw when it fails. Bindings are
+   * deferred to here rather than set in `SetStreamSource`, as Metal defers
+   * them (`:2570-2598` stores, `:2613-2690` binds).
+   *
+   * WHAT IT CANNOT YET HONOUR, IT REFUSES. A program whose layout declares
+   * bind groups needs a resource set realised into `GPUBindGroup`s, and that
+   * half is not ported; drawing without them is a validation error on the GPU,
+   * so the draw is refused here and says why. A stream whose buffer is not a
+   * device buffer - a mesh batch carries a geometry descriptor today - is
+   * refused the same way.
+   *
+   * @param {boolean} indexed Whether the draw reads the bound index buffer.
+   * @returns {boolean} Whether the encoder is ready to draw.
    */
   EmitRenderEncoderState(indexed) {
     if (!this._webgpu) return true;
@@ -1223,18 +1158,18 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * The vertex buffer layouts the bound declaration, program and strides
-   * describe, one per stream slot.
-   *
-   * Metal's `Tr2VertexLayoutAL::SetVertexLayout` (`Tr2VertexLayoutALMetal.mm:205-245`):
-   * match the program's pipeline inputs against the declaration's items, and
-   * stamp each active stream's stride. An input the declaration lacks gets no
-   * attribute - Metal points it at a dummy stream - and a stream no input
-   * reads gets no layout.
-   *
-   * @returns {Array<object|null>|string} The layouts by slot, or what is
-   *   missing when they cannot be built.
+  /**
+   * The vertex buffer layouts the bound declaration, program and strides
+   * describe, one per stream slot.
+   *
+   * Metal's `Tr2VertexLayoutAL::SetVertexLayout` (`Tr2VertexLayoutALMetal.mm:205-245`):
+   * match the program's pipeline inputs against the declaration's items, and
+   * stamp each active stream's stride. An input the declaration lacks gets no
+   * attribute - Metal points it at a dummy stream - and a stream no input
+   * reads gets no layout.
+   *
+   * @returns {Array<object|null>|string} The layouts by slot, or what is
+   *   missing when they cannot be built.
    */
   BuildVertexBufferLayouts() {
     const layout = this._vertexLayout;
@@ -1274,37 +1209,37 @@ class CjsWebgpuRenderContextAL {
     return layouts;
   }
 
-  /**
-   * Bind groups by `program | group | resource set | constant buffers`.
-   *
-   * DX12's descriptor tables live on the CONTEXT, per back buffer
-   * (`Tr2RenderContextDx12.h:269`), and are committed at `SetAllState`
-   * (`:875`); Metal binds per stage inside `EmitRenderEncoderState`
-   * (`MetalWorkQueue.mm:2613-2690`). A WebGPU bind group is an immutable object
-   * made of both the set's entries and the bound constant buffers, so it is
-   * made here, at the draw, and kept by the identities that produced it.
+  /**
+   * Bind groups by `program | group | resource set | constant buffers`.
+   *
+   * DX12's descriptor tables live on the CONTEXT, per back buffer
+   * (`Tr2RenderContextDx12.h:269`), and are committed at `SetAllState`
+   * (`:875`); Metal binds per stage inside `EmitRenderEncoderState`
+   * (`MetalWorkQueue.mm:2613-2690`). A WebGPU bind group is an immutable object
+   * made of both the set's entries and the bound constant buffers, so it is
+   * made here, at the draw, and kept by the identities that produced it.
    */
   _bindGroups = new Map();
 
-  /**
-   * Builds or reuses one bind group per program group and names them for the
-   * draw.
-   *
-   * The program's uniform slots read the constant buffers `SetConstants` bound
-   * at that stage and register - Carbon's parallel road for CBs - uploading
-   * each buffer's shadow if it changed, which is where Carbon's token is
-   * consumed. Every other slot reads the resource set; with no set bound, or a
-   * set made for another program, the slots take dummies, which is Metal's
-   * `SetDummyResources` (`Tr2RenderContextMetal.mm:527-530`).
-   *
-   * @returns {boolean} Whether every group could be built.
+  /**
+   * Builds or reuses one bind group per program group and names them for the
+   * draw.
+   *
+   * The program's uniform slots read the constant buffers `SetConstants` bound
+   * at that stage and register - Carbon's parallel road for CBs - uploading
+   * each buffer's shadow if it changed, which is where Carbon's token is
+   * consumed. Every other slot reads the resource set; with no set bound, or a
+   * set made for another program, the slots take dummies, which is Metal's
+   * `SetDummyResources` (`Tr2RenderContextMetal.mm:527-530`).
+   *
+   * @returns {boolean} Whether every group could be built.
    */
   _EmitBindGroups() {
     const program = this._shaderProgram;
     const layouts = program.GetBindGroupLayouts();
     if (!layouts.length) return true;
-    const set = this._resourceSet;
-    const entries = set && typeof set.GetEntries === "function" && set.GetProgram() === program ? set.GetEntries() : null;
+    const set = this._resourceSet?.m_resourceSet.implementation;
+    const entries = set && set.IsValid() && set.GetProgram() === program ? set.GetEntries() : null;
     const setId = entries ? set.m_id : 0;
     const bindings = program.GetBindings();
     const device = this._webgpu.GetDevice();
@@ -1384,26 +1319,26 @@ class CjsWebgpuRenderContextAL {
     return this._constantArena;
   }
 
-  /**
-   * Copies constants into this frame's arena and says where they landed.
-   *
-   * CARBON'S TWO OVERLOADS, in one method as JavaScript spells them
-   * (`Tr2RenderContextMetal.mm:679-697`, `Tr2RenderContextDx12.cpp:538-548`):
-   *
-   * - given BYTES, a fresh region every call - Carbon constructs a zeroed
-   *   token each time, so nothing is reused;
-   * - given a `Tr2ConstantBufferAL`, the buffer's OWN token, so a buffer bound
-   *   twice in a frame without a Lock between keeps one region. Carbon reaches
-   *   straight into the impl for it (`buffer.m_buffer->m_token`), which is why
-   *   ours is public.
-   *
-   * Carbon returns a `uint64_t` packing Metal's page and offset together; the
-   * region object is that pair unpacked, which is what a bind group needs.
-   *
-   * @param {object|ArrayBufferView} source A constant buffer, or the bytes.
-   * @param {number} [size] Bytes the binding demands at least.
-   * @returns {{page: number, offset: number, size: number}|null} The region,
-   *   or null when there is nothing to upload - Carbon's `return 0`.
+  /**
+   * Copies constants into this frame's arena and says where they landed.
+   *
+   * CARBON'S TWO OVERLOADS, in one method as JavaScript spells them
+   * (`Tr2RenderContextMetal.mm:679-697`, `Tr2RenderContextDx12.cpp:538-548`):
+   *
+   * - given BYTES, a fresh region every call - Carbon constructs a zeroed
+   *   token each time, so nothing is reused;
+   * - given a `Tr2ConstantBufferAL`, the buffer's OWN token, so a buffer bound
+   *   twice in a frame without a Lock between keeps one region. Carbon reaches
+   *   straight into the impl for it (`buffer.m_buffer->m_token`), which is why
+   *   ours is public.
+   *
+   * Carbon returns a `uint64_t` packing Metal's page and offset together; the
+   * region object is that pair unpacked, which is what a bind group needs.
+   *
+   * @param {object|ArrayBufferView} source A constant buffer, or the bytes.
+   * @param {number} [size] Bytes the binding demands at least.
+   * @returns {{page: number, offset: number, size: number}|null} The region,
+   *   or null when there is nothing to upload - Carbon's `return 0`.
    */
   UploadConstants(source, size = 0) {
     if (!this._webgpu || !source) return null;
@@ -1427,13 +1362,13 @@ class CjsWebgpuRenderContextAL {
     return token;
   }
 
-  /**
-   * NOT PORTED, and Metal-only in Carbon. `UseConstantBuffer` makes a constant
-   * buffer resident on the COMPUTE encoder (`useResource:`,
-   * `Tr2RenderContextMetal.mm:1658-1673`) and its only callers build the
-   * ray-tracing shader table (`Tr2RtShaderTableALMetal.mm:61-68`). DX12 has no
-   * such method. This backend dispatches no compute and has no ray tracing, so
-   * there is nothing to make resident.
+  /**
+   * NOT PORTED, and Metal-only in Carbon. `UseConstantBuffer` makes a constant
+   * buffer resident on the COMPUTE encoder (`useResource:`,
+   * `Tr2RenderContextMetal.mm:1658-1673`) and its only callers build the
+   * ray-tracing shader table (`Tr2RtShaderTableALMetal.mm:61-68`). DX12 has no
+   * such method. This backend dispatches no compute and has no ray tracing, so
+   * there is nothing to make resident.
    */
 
   /** The constant buffer `SetConstants` bound for a uniform binding, by any visible stage. */
@@ -1468,15 +1403,15 @@ class CjsWebgpuRenderContextAL {
     buffers: new Map()
   };
 
-  /**
-   * A 1x1 texture view of the given dimension, for a slot nothing filled.
-   *
-   * `MetalContext::GetDummyTexture( MTLTextureType )` (`MetalContext.mm:306-320`):
-   * one per texture type, because a sampler of the wrong dimension is a
-   * validation error rather than a black texel.
-   *
-   * @param {string} [viewDimension] A `GPUTextureViewDimension`.
-   * @returns {object} A `GPUTextureView`.
+  /**
+   * A 1x1 texture view of the given dimension, for a slot nothing filled.
+   *
+   * `MetalContext::GetDummyTexture( MTLTextureType )` (`MetalContext.mm:306-320`):
+   * one per texture type, because a sampler of the wrong dimension is a
+   * validation error rather than a black texel.
+   *
+   * @param {string} [viewDimension] A `GPUTextureViewDimension`.
+   * @returns {object} A `GPUTextureView`.
    */
   GetDummyTexture(viewDimension = "2d") {
     const existing = this._dummies.textures.get(viewDimension);
@@ -1509,14 +1444,14 @@ class CjsWebgpuRenderContextAL {
     return this._dummies.sampler;
   }
 
-  /**
-   * A zeroed buffer of at least `size` bytes for a slot nothing filled.
-   *
-   * DX12's null CB / null SRV substitution, one per size and usage.
-   *
-   * @param {number} size Bytes the layout demands.
-   * @param {"UNIFORM"|"STORAGE"} usageName The usage flag's name.
-   * @returns {object} A `GPUBuffer`.
+  /**
+   * A zeroed buffer of at least `size` bytes for a slot nothing filled.
+   *
+   * DX12's null CB / null SRV substitution, one per size and usage.
+   *
+   * @param {number} size Bytes the layout demands.
+   * @param {"UNIFORM"|"STORAGE"} usageName The usage flag's name.
+   * @returns {object} A `GPUBuffer`.
    */
   GetNullBuffer(size, usageName) {
     const aligned = Math.max(16, Math.ceil(size / 16) * 16);
@@ -1533,12 +1468,12 @@ class CjsWebgpuRenderContextAL {
     return buffer;
   }
 
-  /**
-   * Creates a texture, this backend's kind of `Tr2TextureAL`.
-   *
-   * @param {object} desc A `Tr2BitmapDimensions`.
-   * @param {object} options `{ gpuUsage, cpuUsage, msaa, initialData }`.
-   * @returns {object|null} The texture, or null when Create refused.
+  /**
+   * Creates a texture, this backend's kind of `Tr2TextureAL`.
+   *
+   * @param {object} desc A `Tr2BitmapDimensions`.
+   * @param {object} options `{ gpuUsage, cpuUsage, msaa, initialData }`.
+   * @returns {object|null} The texture, or null when Create refused.
    */
   CreateTexture(desc, options) {
     const texture = new CjsWebgpuTextureAL();
@@ -1546,15 +1481,26 @@ class CjsWebgpuRenderContextAL {
     return texture;
   }
 
-  /**
-   * Creates a resource set, this backend's kind of `Tr2ResourceSetAL`.
-   *
-   * @param {object} description A `Tr2ResourceSetDescriptionAL`.
-   * @param {object} program The `CjsWebgpuShaderProgramAL` it binds against.
-   * @returns {object|null} The set, or null when Create refused.
-   */
-  CreateResourceSet(description, program) {
-    const resourceSet = new CjsWebgpuResourceSetAL();
+  /**
+   * Creates a resource set, this backend's kind of `Tr2ResourceSetAL`.
+   *
+   * @param {object} description A `Tr2ResourceSetDescriptionAL`.
+   * @param {object} program The `CjsWebgpuShaderProgramAL` it binds against.
+   * @returns {object|null} The set, or null when Create refused.
+   */
+  CreateResourceSet(description, program, implementationOnly = false) {
+    // JS platform selection for the public facade; the allocation branch
+    // returns the native status code without collapsing it to null.
+    if (implementationOnly) {
+      const implementation = new CjsWebgpuResourceSetAL();
+      const result = implementation.Create(description, program, this);
+      if (Failed(result)) implementation.Destroy();
+      return {
+        result,
+        implementation
+      };
+    }
+    const resourceSet = new Tr2ResourceSetAL();
     if (Failed(resourceSet.Create(description, program, this))) return null;
     return resourceSet;
   }
@@ -1565,11 +1511,11 @@ class CjsWebgpuRenderContextAL {
     return false;
   }
 
-  /**
-   * Creates the `GPURenderPipeline` a program and recipe describe.
-   *
-   * A program without a pixel stage is a depth-only pipeline, which WebGPU
-   * spells by omitting `fragment` - Carbon's shadow passes are exactly this.
+  /**
+   * Creates the `GPURenderPipeline` a program and recipe describe.
+   *
+   * A program without a pixel stage is a depth-only pipeline, which WebGPU
+   * spells by omitting `fragment` - Carbon's shadow passes are exactly this.
    */
   _CreateRenderPipeline(program, recipe) {
     const fragmentModule = program.GetModuleFor(ShaderType.PIXEL_SHADER);
@@ -1599,15 +1545,15 @@ class CjsWebgpuRenderContextAL {
     return this._webgpu.GetDevice().createRenderPipeline(descriptor);
   }
 
-  /**
-   * Copies the bound attachments' formats onto the description.
-   *
-   * Deferred to the read rather than done in `SetRenderTarget`, because the
-   * canvas format is only known once the target is configured and a target can
-   * be bound before that. Carbon has no equivalent hop: a DX12 render-target
-   * format is written straight into the description by `SetRenderState`
-   * (`Tr2RenderContextDx12.cpp:453`), because a D3D texture knows its format
-   * from creation.
+  /**
+   * Copies the bound attachments' formats onto the description.
+   *
+   * Deferred to the read rather than done in `SetRenderTarget`, because the
+   * canvas format is only known once the target is configured and a target can
+   * be bound before that. Carbon has no equivalent hop: a DX12 render-target
+   * format is written straight into the description by `SetRenderState`
+   * (`Tr2RenderContextDx12.cpp:453`), because a D3D texture knows its format
+   * from creation.
    */
   _RefreshAttachmentFormats() {
     const primary = this._boundRenderTargets[0];
@@ -1632,39 +1578,41 @@ class CjsWebgpuRenderContextAL {
     this._psoDescription.sampleCount = renderTargetBound ? this._renderTarget.GetSampleCount() : 1;
   }
 
-  /**
-   * Binds a prepared set of textures, samplers and buffers.
-   *
-   * @param {object} resourceSet A `Tr2ResourceSetAL`.
-   * @returns {boolean} True.
+  /**
+   * Binds a prepared set of textures, samplers and buffers.
+   *
+   * @param {object} resourceSet A `Tr2ResourceSetAL`.
+   * @returns {boolean} True.
    */
   SetResourceSet(resourceSet) {
-    this._resourceSet = resourceSet;
+    this._resourceSet = resourceSet ? new Tr2ResourceSetAL({
+      copy: resourceSet
+    }) : null;
     return true;
   }
 
-  /**
-   * m_constantBuffers[stage][register], as Metal keeps them.
-   *
-   * A Map keyed by `stage * CONSTANT_BUFFER_REGISTERS + register` rather than a
-   * fixed two-dimensional array, because the register count is a device limit
-   * here and not a compile-time constant.
+  /**
+   * m_constantBuffers[stage][register], as Metal keeps them.
+   *
+   * A Map keyed by `stage * CONSTANT_BUFFER_REGISTERS + register` rather than a
+   * fixed two-dimensional array, because the register count is a device limit
+   * here and not a compile-time constant.
    */
   _constantBuffers = new Map();
 
-  /**
-   * Binds a constant buffer to one shader stage at one register.
-   *
-   * Carbon rejects a register past the backend's constant-buffer count and
-   * otherwise hands the buffer to itself to bind
-   * (`Tr2RenderContextMetal.mm:664-677`). The bound state is what the resolver
-   * reads when it assembles a draw.
-   *
-   * @param {object} buffer A `Tr2ConstantBufferAL`.
-   * @param {number} constantType A `ShaderType`.
-   * @param {number} registerIndex The constant-buffer register.
-   * @param {number} [_maxRegisterCount] Carbon's optional bound.
-   * @returns {boolean} Whether the AL accepted it.
+  /**
+   * Binds a constant buffer to one shader stage at one register.
+   *
+   * Carbon rejects a register past the backend's constant-buffer count and
+   * otherwise hands the buffer to itself to bind
+   * (`Tr2RenderContextMetal.mm:664-677`). The bound state is what the resolver
+   * reads when it assembles a draw.
+   *
+   * @param {object} buffer A `Tr2ConstantBufferAL`.
+   * @param {number} constantType A `ShaderType`.
+   * @param {number} registerIndex The constant-buffer register.
+   * @param {number} [_maxRegisterCount] Carbon's optional bound.
+   * @returns {boolean} Whether the AL accepted it.
    */
   SetConstants(buffer, constantType, registerIndex, _maxRegisterCount = 0) {
     if (registerIndex < 0 || registerIndex >= CONSTANT_BUFFER_REGISTERS) return false;
@@ -1673,12 +1621,12 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * The constant buffer bound to one stage and register.
-   *
-   * @param {number} constantType A `ShaderType`.
-   * @param {number} registerIndex The constant-buffer register.
-   * @returns {object|null} The buffer, or null when nothing is bound.
+  /**
+   * The constant buffer bound to one stage and register.
+   *
+   * @param {number} constantType A `ShaderType`.
+   * @param {number} registerIndex The constant-buffer register.
+   * @returns {object|null} The buffer, or null when nothing is bound.
    */
   GetConstants(constantType, registerIndex) {
     return this._constantBuffers.get(constantType * CONSTANT_BUFFER_REGISTERS + registerIndex) ?? null;
@@ -1693,13 +1641,13 @@ class CjsWebgpuRenderContextAL {
   // changes". Each one either does what WebGPU can do or reports what the stub
   // reports, and says which.
 
-  /**
-   * Where a debug group was pushed, so its pop reaches the same encoder.
-   *
-   * WEBGPU REQUIRES THE PAIR TO BALANCE WITHIN ONE ENCODER. A group pushed on
-   * the command encoder and popped after a render pass opened would be a
-   * validation error, not a mislabelled capture - so the push records its
-   * target and the pop uses it rather than asking again.
+  /**
+   * Where a debug group was pushed, so its pop reaches the same encoder.
+   *
+   * WEBGPU REQUIRES THE PAIR TO BALANCE WITHIN ONE ENCODER. A group pushed on
+   * the command encoder and popped after a render pass opened would be a
+   * validation error, not a mislabelled capture - so the push records its
+   * target and the pop uses it rather than asking again.
    */
   _markerStack = [];
 
@@ -1708,23 +1656,23 @@ class CjsWebgpuRenderContextAL {
     return this._workQueue.GetRenderPass() ?? this._commandEncoder;
   }
 
-  /**
-   * Inserts a one-off marker into the capture.
-   *
-   * Real, unlike the stub's empty body: `insertDebugMarker` is what a WebGPU
-   * capture tool shows, and this is the only reason Carbon's markers exist.
-   *
-   * @param {string} marker The label.
+  /**
+   * Inserts a one-off marker into the capture.
+   *
+   * Real, unlike the stub's empty body: `insertDebugMarker` is what a WebGPU
+   * capture tool shows, and this is the only reason Carbon's markers exist.
+   *
+   * @param {string} marker The label.
    */
   AddGpuMarker(marker) {
     const target = this._MarkerTarget();
     if (target) target.insertDebugMarker(String(marker));
   }
 
-  /**
-   * Opens a named debug group.
-   *
-   * @param {string} marker The label.
+  /**
+   * Opens a named debug group.
+   *
+   * @param {string} marker The label.
    */
   PushGpuMarker(marker) {
     const target = this._MarkerTarget();
@@ -1738,19 +1686,19 @@ class CjsWebgpuRenderContextAL {
     if (target) target.popDebugGroup();
   }
 
-  /**
-   * Marks a point in the frame for a profiler.
-   *
-   * @param {string} frameEvent The event name.
+  /**
+   * Marks a point in the frame for a profiler.
+   *
+   * @param {string} frameEvent The event name.
    */
   MarkFrameEvent(frameEvent) {
     this.AddGpuMarker(frameEvent);
   }
 
-  /**
-   * Tears the device down, dropping every piece of bound state.
-   *
-   * @returns {boolean} True.
+  /**
+   * Tears the device down, dropping every piece of bound state.
+   *
+   * @returns {boolean} True.
    */
   Destroy() {
     this._boundRenderTargets.fill(null);
@@ -1782,16 +1730,16 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Binds the default back buffer at slot zero and clears every other slot.
-   *
-   * Carbon calls this from `BeginScene` (`Tr2RenderContextMetal.mm:860-864`),
-   * which is why a frame there never inherits the previous frame's targets.
-   * This backend did not, so bound targets survived across frames and the first
-   * pass of a frame drew into whatever the last pass of the previous one had
-   * left bound - the same shape as the 2048 shadow-map defect one layer up.
-   *
-   * @returns {boolean} True.
+  /**
+   * Binds the default back buffer at slot zero and clears every other slot.
+   *
+   * Carbon calls this from `BeginScene` (`Tr2RenderContextMetal.mm:860-864`),
+   * which is why a frame there never inherits the previous frame's targets.
+   * This backend did not, so bound targets survived across frames and the first
+   * pass of a frame drew into whatever the last pass of the previous one had
+   * left bound - the same shape as the 2048 shadow-map defect one layer up.
+   *
+   * @returns {boolean} True.
    */
   ResetRenderTargets() {
     this.SetDepthStencil(null);
@@ -1800,28 +1748,28 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Marks this context as the process-wide primary one.
-   *
-   * Carbon's Metal version also constructs the device-side context and the
-   * default back buffer (`Tr2RenderContextMetal.mm:114-124`); ours receive both
-   * through the constructor, so what remains is the registration.
-   *
-   * @returns {boolean} True.
+  /**
+   * Marks this context as the process-wide primary one.
+   *
+   * Carbon's Metal version also constructs the device-side context and the
+   * default back buffer (`Tr2RenderContextMetal.mm:114-124`); ours receive both
+   * through the constructor, so what remains is the registration.
+   *
+   * @returns {boolean} True.
    */
   SetAsPrimary() {
     CjsWebgpuRenderContextAL.SetPrimaryRenderContext(this);
     return true;
   }
 
-  /**
-   * The present parameters last applied.
-   *
-   * CARBON'S MISSPELLING IS KEPT (`Tr2RenderContextMetal.h:230`). It is the
-   * name on the abstraction-layer contract, and a backend that spells it
-   * correctly is a backend the contract cannot reach.
-   *
-   * @returns {object|null} The parameters, or null before any were set.
+  /**
+   * The present parameters last applied.
+   *
+   * CARBON'S MISSPELLING IS KEPT (`Tr2RenderContextMetal.h:230`). It is the
+   * name on the abstraction-layer contract, and a backend that spells it
+   * correctly is a backend the contract cannot reach.
+   *
+   * @returns {object|null} The parameters, or null before any were set.
    */
   GetPresentParamaters() {
     return this._presentParameters;
@@ -1830,10 +1778,10 @@ class CjsWebgpuRenderContextAL {
   /** m_presentParameters */
   _presentParameters = null;
 
-  /**
-   * Releases what a device reset would invalidate, keeping the context alive.
-   *
-   * @returns {boolean} True.
+  /**
+   * Releases what a device reset would invalidate, keeping the context alive.
+   *
+   * @returns {boolean} True.
    */
   ReleaseDeviceResources() {
     this._boundRenderTargets.fill(null);
@@ -1859,39 +1807,39 @@ class CjsWebgpuRenderContextAL {
     // second state and report a change it had not made.
   }
 
-  /**
-   * The back buffer this context presents into.
-   *
-   * The render target IS this backend's back buffer: it answers `GetWidth` and
-   * `GetHeight` exactly as a `Tr2TextureAL` does, which is why it can be bound
-   * at slot zero without an adapter.
-   *
-   * @returns {object|null} The render target, or null before composition.
+  /**
+   * The back buffer this context presents into.
+   *
+   * The render target IS this backend's back buffer: it answers `GetWidth` and
+   * `GetHeight` exactly as a `Tr2TextureAL` does, which is why it can be bound
+   * at slot zero without an adapter.
+   *
+   * @returns {object|null} The render target, or null before composition.
    */
   GetDefaultBackBuffer() {
     return this._renderTarget;
   }
 
-  /**
-   * The back buffer's pixel format, as a Carbon `PixelFormat`.
-   *
-   * @returns {number} The format, or `PIXEL_FORMAT_UNKNOWN` before composition
-   *   or for a canvas format outside the four the spec allows.
+  /**
+   * The back buffer's pixel format, as a Carbon `PixelFormat`.
+   *
+   * @returns {number} The format, or `PIXEL_FORMAT_UNKNOWN` before composition
+   *   or for a canvas format outside the four the spec allows.
    */
   GetBackBufferFormat() {
     if (!this._renderTarget) return PixelFormat.PIXEL_FORMAT_UNKNOWN;
     return CANVAS_PIXEL_FORMAT[this._renderTarget.GetFormat()] ?? PixelFormat.PIXEL_FORMAT_UNKNOWN;
   }
 
-  /**
-   * Applies present parameters by resizing the presentation surface.
-   *
-   * The stub CREATES a back buffer at the requested size; here the canvas
-   * already exists and is reconfigured instead, which is the same act against a
-   * surface the page owns rather than one the backend allocates.
-   *
-   * @param {object} presentParameters Carbon's `Tr2PresentParametersAL`.
-   * @returns {number} An `ALResult` value.
+  /**
+   * Applies present parameters by resizing the presentation surface.
+   *
+   * The stub CREATES a back buffer at the requested size; here the canvas
+   * already exists and is reconfigured instead, which is the same act against a
+   * surface the page owns rather than one the backend allocates.
+   *
+   * @param {object} presentParameters Carbon's `Tr2PresentParametersAL`.
+   * @returns {number} An `ALResult` value.
    */
   SetPresentParameters(presentParameters) {
     if (!presentParameters || !presentParameters.mode) return ALResult.E_INVALIDARG;
@@ -1908,22 +1856,22 @@ class CjsWebgpuRenderContextAL {
     return ALResult.S_OK;
   }
 
-  /**
-   * Whether textures can be reached without a binding.
-   *
-   * @returns {boolean} False. WebGPU has no bindless path at all: every
-   *   resource is reached through a bind group.
+  /**
+   * Whether textures can be reached without a binding.
+   *
+   * @returns {boolean} False. WebGPU has no bindless path at all: every
+   *   resource is reached through a bind group.
    */
   SupportsBindlessTextures() {
     return false;
   }
 
-  /**
-   * How much video memory the adapter has.
-   *
-   * @returns {number} Zero, as the stub reports. WebGPU deliberately exposes no
-   *   memory size - it is a fingerprinting surface - so this is not a gap that
-   *   a later browser fills in.
+  /**
+   * How much video memory the adapter has.
+   *
+   * @returns {number} Zero, as the stub reports. WebGPU deliberately exposes no
+   *   memory size - it is a fingerprinting surface - so this is not a gap that
+   *   a later browser fills in.
    */
   GetTotalVideoMemory() {
     return 0;
@@ -1932,41 +1880,41 @@ class CjsWebgpuRenderContextAL {
   /** m_readOnlyDepth - Metal keeps this and folds it into ZWRITEENABLE. */
   _readOnlyDepth = false;
 
-  /**
-   * Whether depth is bound read-only.
-   *
-   * @returns {boolean} The flag.
+  /**
+   * Whether depth is bound read-only.
+   *
+   * @returns {boolean} The flag.
    */
   GetReadOnlyDepth() {
     return this._readOnlyDepth;
   }
 
-  /**
-   * Binds depth read-only, so it can be sampled while still testing.
-   *
-   * STORED, NOT YET APPLIED. WebGPU expresses this as `depthReadOnly` on the
-   * render-pass descriptor, which `_Descriptor` builds; wiring it there is a
-   * pass-descriptor change rather than a state one, and the flag has to exist
-   * before it can be read.
-   *
-   * @param {boolean} enable Whether depth is read-only.
+  /**
+   * Binds depth read-only, so it can be sampled while still testing.
+   *
+   * STORED, NOT YET APPLIED. WebGPU expresses this as `depthReadOnly` on the
+   * render-pass descriptor, which `_Descriptor` builds; wiring it there is a
+   * pass-descriptor change rather than a state one, and the flag has to exist
+   * before it can be read.
+   *
+   * @param {boolean} enable Whether depth is read-only.
    */
   SetReadOnlyDepth(enable) {
     this._readOnlyDepth = !!enable;
   }
 
-  /**
-   * Copies a byte range between two buffers.
-   *
-   * Real when a frame is open: `copyBufferToBuffer` is a command-encoder verb,
-   * so it needs the encoder `BeginScene` created and nothing else.
-   *
-   * @param {object} destination The destination `Tr2BufferAL`.
-   * @param {number} destinationOffset Byte offset into it.
-   * @param {object} source The source `Tr2BufferAL`.
-   * @param {number} sourceOffset Byte offset into it.
-   * @param {number} size Bytes to copy.
-   * @returns {boolean} Whether the copy was encoded.
+  /**
+   * Copies a byte range between two buffers.
+   *
+   * Real when a frame is open: `copyBufferToBuffer` is a command-encoder verb,
+   * so it needs the encoder `BeginScene` created and nothing else.
+   *
+   * @param {object} destination The destination `Tr2BufferAL`.
+   * @param {number} destinationOffset Byte offset into it.
+   * @param {object} source The source `Tr2BufferAL`.
+   * @param {number} sourceOffset Byte offset into it.
+   * @param {number} size Bytes to copy.
+   * @returns {boolean} Whether the copy was encoded.
    */
   CopySubBuffer(destination, destinationOffset, source, sourceOffset, size) {
     if (!this._commandEncoder) return false;
@@ -1976,76 +1924,76 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Draws indirectly, reading the draw arguments from a buffer.
-   *
-   * REFUSES, as the stub does. WebGPU has `drawIndirect`, but the work queue
-   * owns every draw and has no indirect verb; adding one here would put a
-   * second draw path beside the queue's, which is the split this backend is
-   * built around.
-   *
-   * @returns {boolean} False.
+  /**
+   * Draws indirectly, reading the draw arguments from a buffer.
+   *
+   * REFUSES, as the stub does. WebGPU has `drawIndirect`, but the work queue
+   * owns every draw and has no indirect verb; adding one here would put a
+   * second draw path beside the queue's, which is the split this backend is
+   * built around.
+   *
+   * @returns {boolean} False.
    */
   DrawInstancedIndirect() {
     return false;
   }
 
-  /**
-   * Draws indexed indirectly.
-   *
-   * @returns {boolean} False; see `DrawInstancedIndirect`.
+  /**
+   * Draws indexed indirectly.
+   *
+   * @returns {boolean} False; see `DrawInstancedIndirect`.
    */
   DrawIndexedInstancedIndirect() {
     return false;
   }
 
-  /**
-   * Declares that a batch of resources is about to be used.
-   *
-   * @param {object} _destination Where they are used.
-   * @param {number} _usage How they are used.
-   * @param {object[]} _resources The resources.
-   * @returns {boolean} True. This is a residency and barrier hint for backends
-   *   that place their own memory; WebGPU tracks both itself, so honouring it
-   *   is nothing rather than unimplemented.
+  /**
+   * Declares that a batch of resources is about to be used.
+   *
+   * @param {object} _destination Where they are used.
+   * @param {number} _usage How they are used.
+   * @param {object[]} _resources The resources.
+   * @returns {boolean} True. This is a residency and barrier hint for backends
+   *   that place their own memory; WebGPU tracks both itself, so honouring it
+   *   is nothing rather than unimplemented.
    */
   UseResources(_destination, _usage, _resources) {
     return true;
   }
 
-  /**
-   * Declares a ray-tracing acceleration structure in use.
-   *
-   * @param {object} _tlas The top-level structure.
-   * @returns {boolean} True, as the stub reports.
+  /**
+   * Declares a ray-tracing acceleration structure in use.
+   *
+   * @param {object} _tlas The top-level structure.
+   * @returns {boolean} True, as the stub reports.
    */
   UseAccelerationStructure(_tlas) {
     return true;
   }
 
-  /**
-   * Dispatches rays.
-   *
-   * @returns {boolean} False; WebGPU has no ray-tracing pipeline.
+  /**
+   * Dispatches rays.
+   *
+   * @returns {boolean} False; WebGPU has no ray-tracing pipeline.
    */
   DispatchRays() {
     return false;
   }
 
-  /**
-   * Whether the device recorded a GPU state marker after a fault.
-   *
-   * @returns {boolean} False; WebGPU surfaces device loss as a promise and a
-   *   reason string, with no marker or breadcrumb to read.
+  /**
+   * Whether the device recorded a GPU state marker after a fault.
+   *
+   * @returns {boolean} False; WebGPU surfaces device loss as a promise and a
+   *   reason string, with no marker or breadcrumb to read.
    */
   GetGpuStateMarker() {
     return false;
   }
 
-  /**
-   * The resource a GPU page fault named.
-   *
-   * @returns {boolean} False; see `GetGpuStateMarker`.
+  /**
+   * The resource a GPU page fault named.
+   *
+   * @returns {boolean} False; see `GetGpuStateMarker`.
    */
   GetGpuPageFaultResource() {
     return false;
@@ -2055,30 +2003,30 @@ class CjsWebgpuRenderContextAL {
   // Carbon's: the family is live only in the DX backends. WebGPU has no
   // upscaler to reach, so these are complete rather than pending.
 
-  /**
-   * Enables upscaling.
-   *
-   * @returns {number} `UpscalingResult.OK` - Carbon's stub succeeds WITHOUT
-   *   creating anything, so a caller that then asks for a context gets null.
-   *   That pairing is Carbon's and both halves are kept.
+  /**
+   * Enables upscaling.
+   *
+   * @returns {number} `UpscalingResult.OK` - Carbon's stub succeeds WITHOUT
+   *   creating anything, so a caller that then asks for a context gets null.
+   *   That pairing is Carbon's and both halves are kept.
    */
   EnableUpscaling() {
     return UpscalingResult.OK;
   }
 
-  /**
-   * An existing upscaling context.
-   *
-   * @returns {null} Null; none is kept.
+  /**
+   * An existing upscaling context.
+   *
+   * @returns {null} Null; none is kept.
    */
   GetUpscalingContext() {
     return null;
   }
 
-  /**
-   * Creates an upscaling context.
-   *
-   * @returns {null} Null; none is created.
+  /**
+   * Creates an upscaling context.
+   *
+   * @returns {null} Null; none is created.
    */
   CreateUpscalingContext() {
     return null;
@@ -2087,10 +2035,10 @@ class CjsWebgpuRenderContextAL {
   /** Destroys an upscaling context; there are none. */
   DeleteUpscalingContext() {}
 
-  /**
-   * What an upscaling context is doing.
-   *
-   * @returns {object} A default `UpscalingInfo`; two of its values are not zero.
+  /**
+   * What an upscaling context is doing.
+   *
+   * @returns {object} A default `UpscalingInfo`; two of its values are not zero.
    */
   GetUpscalingInfo() {
     return {
@@ -2110,19 +2058,19 @@ class CjsWebgpuRenderContextAL {
     };
   }
 
-  /**
-   * The techniques an adapter supports.
-   *
-   * @returns {Array} Empty.
+  /**
+   * The techniques an adapter supports.
+   *
+   * @returns {Array} Empty.
    */
   GetSupportedUpscalingTechniques() {
     return [];
   }
 
-  /**
-   * The upscaling currently set up.
-   *
-   * @returns {object} "No upscaling", in the four fields Carbon fills.
+  /**
+   * The upscaling currently set up.
+   *
+   * @returns {object} "No upscaling", in the four fields Carbon fills.
    */
   GetUpscalingSetup() {
     return {
@@ -2137,47 +2085,47 @@ class CjsWebgpuRenderContextAL {
   // reaches it from resource creation; these are the same three accessors the
   // stub carries, over the same module-level binding.
 
-  /**
-   * Records the primary render context.
-   *
-   * @param {object} renderContext The context to make primary.
+  /**
+   * Records the primary render context.
+   *
+   * @param {object} renderContext The context to make primary.
    */
   static SetPrimaryRenderContext(renderContext) {
     primaryRenderContext = renderContext;
   }
 
-  /**
-   * The primary render context, which must exist.
-   *
-   * @returns {object} The primary context.
+  /**
+   * The primary render context, which must exist.
+   *
+   * @returns {object} The primary context.
    */
   static GetPrimaryRenderContext() {
     if (primaryRenderContext === null) fail("there is no primary render context");
     return primaryRenderContext;
   }
 
-  /**
-   * The primary render context, or null.
-   *
-   * @returns {object|null} The primary context.
+  /**
+   * The primary render context, or null.
+   *
+   * @returns {object|null} The primary context.
    */
   static GetPrimaryRenderContextPointer() {
     return primaryRenderContext;
   }
 
-  /**
-   * Draws the bound geometry, indexed.
-   *
-   * REFUSES WITHOUT AN INDEX BUFFER, as Metal does - `E_INVALIDARG` at
-   * `Tr2RenderContextMetal.mm:419-422`. An indexed draw with nothing to index
-   * is a caller error a backend can catch without a device.
-   *
-   * @param {number} indexCountPerInstance Indices each instance reads.
-   * @param {number} instanceCount Instances to draw.
-   * @param {number} startIndexLocation First index.
-   * @param {number} baseVertexLocation Value added to every index.
-   * @param {number} startInstanceLocation First instance id.
-   * @returns {boolean} Whether the draw was recorded.
+  /**
+   * Draws the bound geometry, indexed.
+   *
+   * REFUSES WITHOUT AN INDEX BUFFER, as Metal does - `E_INVALIDARG` at
+   * `Tr2RenderContextMetal.mm:419-422`. An indexed draw with nothing to index
+   * is a caller error a backend can catch without a device.
+   *
+   * @param {number} indexCountPerInstance Indices each instance reads.
+   * @param {number} instanceCount Instances to draw.
+   * @param {number} startIndexLocation First index.
+   * @param {number} baseVertexLocation Value added to every index.
+   * @param {number} startInstanceLocation First instance id.
+   * @returns {boolean} Whether the draw was recorded.
    */
   DrawIndexedInstanced(indexCountPerInstance, instanceCount, startIndexLocation = 0, baseVertexLocation = 0, startInstanceLocation = 0) {
     if (!this._indexBuffer) return false;
@@ -2194,14 +2142,14 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Draws the bound geometry, non-indexed.
-   *
-   * @param {number} vertexCountPerInstance Vertices each instance reads.
-   * @param {number} instanceCount Instances to draw.
-   * @param {number} startVertexLocation First vertex.
-   * @param {number} startInstanceLocation First instance id.
-   * @returns {boolean} Whether the draw was recorded.
+  /**
+   * Draws the bound geometry, non-indexed.
+   *
+   * @param {number} vertexCountPerInstance Vertices each instance reads.
+   * @param {number} instanceCount Instances to draw.
+   * @param {number} startVertexLocation First vertex.
+   * @param {number} startInstanceLocation First instance id.
+   * @returns {boolean} Whether the draw was recorded.
    */
   DrawInstanced(vertexCountPerInstance, instanceCount, startVertexLocation = 0, startInstanceLocation = 0) {
     if (!this._shaderProgram) return false;
@@ -2212,81 +2160,81 @@ class CjsWebgpuRenderContextAL {
     return true;
   }
 
-  /**
-   * Draws a primitive COUNT, converting it to vertices first.
-   *
-   * @param {number} numVertices Vertices the index range spans.
-   * @param {number} startIndex First index.
-   * @param {number} primitiveCount Primitives to draw.
-   * @param {number} [minimumIndex] Lowest index present.
-   * @returns {boolean} Whether the draw was recorded.
+  /**
+   * Draws a primitive COUNT, converting it to vertices first.
+   *
+   * @param {number} numVertices Vertices the index range spans.
+   * @param {number} startIndex First index.
+   * @param {number} primitiveCount Primitives to draw.
+   * @param {number} [minimumIndex] Lowest index present.
+   * @returns {boolean} Whether the draw was recorded.
    */
   DrawIndexedPrimitive(numVertices, startIndex, primitiveCount, minimumIndex = 0) {
     return this.DrawIndexedInstanced(this.ComputeVertexCount(primitiveCount), 1, startIndex, minimumIndex, 0);
   }
 
-  /**
-   * Draws a primitive count, non-indexed.
-   *
-   * @param {number} startVertex First vertex.
-   * @param {number} primitiveCount Primitives to draw.
-   * @returns {boolean} Whether the draw was recorded.
+  /**
+   * Draws a primitive count, non-indexed.
+   *
+   * @param {number} startVertex First vertex.
+   * @param {number} primitiveCount Primitives to draw.
+   * @returns {boolean} Whether the draw was recorded.
    */
   DrawPrimitive(startVertex, primitiveCount) {
     return this.DrawInstanced(this.ComputeVertexCount(primitiveCount), 1, startVertex, 0);
   }
 
-  /**
-   * Draws non-indexed straight from caller memory, with no buffer bound.
-   *
-   * Carbon does not draw this itself either: every backend hands it to
-   * `Tr2DrawUPHelper` (Metal at `Tr2RenderContextMetal.mm:558-571`, DX12 at
-   * `Tr2RenderContextDx12.cpp:1219-1224`), which stages the caller's vertices
-   * into a ring of scratch buffers and issues an ordinary draw. WebGPU cannot
-   * read caller memory either - every vertex must reach a `GPUBuffer` first -
-   * so the helper IS the implementation rather than a detail of it, and the
-   * port is shared rather than written again here.
-   *
-   * @param {number} primitiveCount Primitives to draw.
-   * @param {ArrayBufferView} vertexStreamZeroData The vertices.
-   * @param {number} vertexStreamZeroStride Bytes per vertex.
-   * @returns {boolean} Whether the draw was encoded.
+  /**
+   * Draws non-indexed straight from caller memory, with no buffer bound.
+   *
+   * Carbon does not draw this itself either: every backend hands it to
+   * `Tr2DrawUPHelper` (Metal at `Tr2RenderContextMetal.mm:558-571`, DX12 at
+   * `Tr2RenderContextDx12.cpp:1219-1224`), which stages the caller's vertices
+   * into a ring of scratch buffers and issues an ordinary draw. WebGPU cannot
+   * read caller memory either - every vertex must reach a `GPUBuffer` first -
+   * so the helper IS the implementation rather than a detail of it, and the
+   * port is shared rather than written again here.
+   *
+   * @param {number} primitiveCount Primitives to draw.
+   * @param {ArrayBufferView} vertexStreamZeroData The vertices.
+   * @param {number} vertexStreamZeroStride Bytes per vertex.
+   * @returns {boolean} Whether the draw was encoded.
    */
   DrawPrimitiveUP(primitiveCount, vertexStreamZeroData, vertexStreamZeroStride) {
     return !Failed(this._drawUP.DrawPrimitiveUP(this._topology, primitiveCount, vertexStreamZeroData, vertexStreamZeroStride, this));
   }
 
-  /**
-   * Draws indexed straight from caller memory.
-   *
-   * The same helper, staging indices as well as vertices. Carbon has an
-   * overload per index width; the width is read off the array here instead.
-   *
-   * @param {number} numVertices Vertices the index data spans.
-   * @param {number} primitiveCount Primitives to draw.
-   * @param {Uint16Array|Uint32Array} indexData The indices.
-   * @param {ArrayBufferView} vertexStreamZeroData The vertices.
-   * @param {number} vertexStreamZeroStride Bytes per vertex.
-   * @returns {boolean} Whether the draw was encoded.
+  /**
+   * Draws indexed straight from caller memory.
+   *
+   * The same helper, staging indices as well as vertices. Carbon has an
+   * overload per index width; the width is read off the array here instead.
+   *
+   * @param {number} numVertices Vertices the index data spans.
+   * @param {number} primitiveCount Primitives to draw.
+   * @param {Uint16Array|Uint32Array} indexData The indices.
+   * @param {ArrayBufferView} vertexStreamZeroData The vertices.
+   * @param {number} vertexStreamZeroStride Bytes per vertex.
+   * @returns {boolean} Whether the draw was encoded.
    */
   DrawIndexedPrimitiveUP(numVertices, primitiveCount, indexData, vertexStreamZeroData, vertexStreamZeroStride) {
     return !Failed(this._drawUP.DrawIndexedPrimitiveUP(this._topology, numVertices, primitiveCount, indexData, vertexStreamZeroData, vertexStreamZeroStride, this));
   }
 
-  /**
-   * How many vertices a primitive count describes at the bound topology.
-   *
-   * @param {number} primitiveCount Primitives.
-   * @returns {number} Vertices.
+  /**
+   * How many vertices a primitive count describes at the bound topology.
+   *
+   * @param {number} primitiveCount Primitives.
+   * @returns {number} Vertices.
    */
   ComputeVertexCount(primitiveCount) {
     return VERTICES_PER_PRIMITIVE[this._topology](primitiveCount);
   }
 
-  /**
-   * What a following draw would bind, for a caller that must encode it.
-   *
-   * @returns {object} A copy of the bound state.
+  /**
+   * What a following draw would bind, for a caller that must encode it.
+   *
+   * @returns {object} A copy of the bound state.
    */
   GetBoundState() {
     return {
@@ -2302,15 +2250,29 @@ class CjsWebgpuRenderContextAL {
     };
   }
 
-  /**
-   * Keeps the work queue's reported encoder transitions for the tests to read.
-   *
-   * @param {object[]} [events] The events, if any were reported.
+  /**
+   * Keeps the work queue's reported encoder transitions for the tests to read.
+   *
+   * @param {object[]} [events] The events, if any were reported.
    */
   _Record(events) {
     if (events?.length) this._transitions.push(...events);
   }
 }
 
+// DECLARED AS A CALL, NOT A DECORATOR, for the reason recorded in
+// Tr2BitmapDimensions.js: the layer is imported straight from source by its
+// tests and raw Node cannot parse decorator syntax.
+//
+// The donor is NAMED rather than left to be derived from this class's name.
+// Carbon calls every backend's class the same thing and carries the backend in
+// the FILE name, because only one backend compiles at a time; we ship them
+// together, so the backend moves onto the class name. That divergence is the
+// author's to declare, never a checker's to guess.
+CjsSchema.define(CjsWebgpuRenderContextAL, {
+  className: "CjsWebgpuRenderContextAL",
+  carbon: "Tr2RenderContextAL"
+});
+
 export { CjsWebgpuRenderContextAL };
 //# sourceMappingURL=CjsWebgpuRenderContextAL.js.map