@carbonenginejs/runtime 0.1.0-alpha.4 → 0.1.0-alpha.5

package/dist/trinityal/webgpu/CjsWebgpuDevice.js

@@ -1,3 +1,7 @@
+import { HostBitmap } from '#imageio';
+import { CjsImageFormat } from '#resource/format/CjsImageFormat';
+import { CjsSchema } from '#schema';
+import { PixelFormat } from '#consts/render-context';
 import { CjsResource } from '#resource/CjsResource';
 import { CjsWebgpuPipelineCache, CanonicalKey, RenderPipelineKey } from './core/CjsWebgpuPipelineCache.js';
 import { AssertFormatFeature, PlanTextureUpload } from './core/textureLayout.js';
@@ -541,6 +545,68 @@ function mapRgba8TexturePayload(value, plan) {
     textures: frozenRecord([[plan.textureKey, texture]])
   };
 }
+
+/**
+ * The RGBA8 texture record for a texture resource's HostBitmap.
+ *
+ * A texture resource holds Carbon's `ImageIO::HostBitmap` (TriTextureRes.cpp:606),
+ * not a plain payload. This path uploads one RGBA8 level, so the top mip is
+ * converted - block formats decoded - on a COPY: the resource keeps its own
+ * bitmap for other backends and for rebuilds.
+ *
+ * Colour space follows the format, as Carbon's does: an `_SRGB` format uploads
+ * as `rgba8unorm-srgb`, anything else as `rgba8unorm`.
+ *
+ * @param {HostBitmap} bitmap The resource's bitmap.
+ * @param {object} plan The realization plan.
+ * @returns {object} The bundle input.
+ */
+function mapRgba8TextureBitmap(bitmap, plan) {
+  const label = `${plan.name} bitmap`;
+  if (!bitmap.IsValid()) fail(`${label} is not valid`);
+  const srgb = isSrgbCarbonFormat(bitmap.GetFormat());
+  const copy = new HostBitmap();
+  if (!copy.Create(bitmap.GetWidth(), bitmap.GetHeight(), 1, bitmap.GetFormat())) fail(`${label} could not be copied`);
+  copy.GetMipRawData(0).set(bitmap.GetMipRawData(0).subarray(0, bitmap.GetMipSize(0)));
+  const requested = srgb ? PixelFormat.PIXEL_FORMAT_R8G8B8A8_UNORM_SRGB : PixelFormat.PIXEL_FORMAT_R8G8B8A8_UNORM;
+  // Carbon's ConvertFormat reads R8G8 as luminance and alpha; a packed pair is
+  // two channels, so it expands to (R, G, 0, 255) here instead.
+  if (bitmap.GetFormat() === PixelFormat.PIXEL_FORMAT_R8G8_UNORM) expandRg8(copy);else if (!CjsImageFormat.convertImage(copy, requested)) fail(`${label} cannot be converted to RGBA8`);
+  const texture = {
+    width: copy.GetWidth(),
+    height: copy.GetHeight(),
+    format: srgb ? "rgba8unorm-srgb" : "rgba8unorm",
+    bytesPerRow: copy.GetMipPitch(0),
+    data: copy.GetMipRawData(0)
+  };
+  return {
+    label: plan.bundleLabel,
+    textures: frozenRecord([[plan.textureKey, texture]])
+  };
+}
+
+/** Expand an RG8 bitmap's top mip in place to RGBA8 as (R, G, 0, 255). */
+function expandRg8(bitmap) {
+  const width = bitmap.GetWidth();
+  const height = bitmap.GetHeight();
+  const source = bitmap.GetMipRawData(0).slice();
+  const pitch = bitmap.GetMipPitch(0);
+  bitmap.Create(width, height, 1, PixelFormat.PIXEL_FORMAT_R8G8B8A8_UNORM);
+  const target = bitmap.GetMipRawData(0);
+  const targetPitch = bitmap.GetMipPitch(0);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      target[y * targetPitch + x * 4] = source[y * pitch + x * 2];
+      target[y * targetPitch + x * 4 + 1] = source[y * pitch + x * 2 + 1];
+      target[y * targetPitch + x * 4 + 3] = 255;
+    }
+  }
+}
+
+/** Whether a Carbon pixel format is one of the `_SRGB` variants. */
+function isSrgbCarbonFormat(format) {
+  return Object.entries(PixelFormat).some(([name, value]) => value === format && name.endsWith("_SRGB"));
+}
 function mapSamplerPayload(value, plan) {
   assertPlainObject(value, `${plan.name} payload`);
   assertKeys(value, SELECTED_SAMPLER_PAYLOAD_KEYS, `${plan.name} payload`);
@@ -750,7 +816,9 @@ function resolveBindingResource(owner, entry, resource) {
     // Every dimension the texture adapter can create must be bindable, or a
     // cube map is creatable and then unusable. Multisampled textures are still
     // out: those are attachments, and the render target owns them.
-    if (!TEXTURE_VIEW_DIMENSIONS.has(viewDimension) || multisampled || sampleType !== "float") {
+    // A float texture binds to either float slot; "unfilterable-float" is a
+    // slot only ever loaded from, which a 32-bit float texture needs.
+    if (!TEXTURE_VIEW_DIMENSIONS.has(viewDimension) || multisampled || sampleType !== "float" && sampleType !== "unfilterable-float") {
       fail(`${entry.identity} requires a ${multisampled ? "multisampled " : ""}${sampleType} ${viewDimension} texture,` + " which this adapter does not realize");
     }
     // The view's dimension is fixed at creation, so a layout asking for the
@@ -839,14 +907,14 @@ async function popValidationScope(device, state) {
   return device.popErrorScope();
 }
 
-/**
- * Engine-owned WebGPU device boundary. It realizes already-selected Carbon WebGPU
- * descriptors; format/capability policy remains with the caller.
+/**
+ * Engine-owned WebGPU device boundary. It realizes already-selected Carbon WebGPU
+ * descriptors; format/capability policy remains with the caller.
  */
 class CjsWebgpuDevice {
-  /**
-   * Requests or accepts a WebGPU adapter and device, then returns a ready
-   * engine boundary.
+  /**
+   * Requests or accepts a WebGPU adapter and device, then returns a ready
+   * engine boundary.
    */
   static async Request(options = {}) {
     const gpu = Object.prototype.hasOwnProperty.call(options, "gpu") ? options.gpu : globalThis.navigator?.gpu;
@@ -869,8 +937,8 @@ class CjsWebgpuDevice {
     });
   }
 
-  /**
-   * Creates a ready engine boundary around an already-acquired GPU device.
+  /**
+   * Creates a ready engine boundary around an already-acquired GPU device.
    */
   constructor(options = {}) {
     if (!options.device || typeof options.device.createShaderModule !== "function") fail("a GPUDevice is required");
@@ -900,75 +968,75 @@ class CjsWebgpuDevice {
     this._WatchDevice(this._device, this._generation);
   }
 
-  /**
-   * Returns the adapter associated with the boundary, when known.
+  /**
+   * Returns the adapter associated with the boundary, when known.
    */
   GetAdapter() {
     return this._adapter;
   }
 
-  /**
-   * Returns the ready native GPU device.
+  /**
+   * Returns the ready native GPU device.
    */
   GetDevice() {
     this._AssertReady();
     return this._device;
   }
 
-  /**
-   * The `GPUBufferUsage` table this device builds masks from.
-   *
-   * It is injectable (`options.bufferUsage`) so a test can drive buffer
-   * creation without a real WebGPU global.
-   *
-   * @returns {object} The usage flags.
+  /**
+   * The `GPUBufferUsage` table this device builds masks from.
+   *
+   * It is injectable (`options.bufferUsage`) so a test can drive buffer
+   * creation without a real WebGPU global.
+   *
+   * @returns {object} The usage flags.
    */
   GetBufferUsage() {
     return this._bufferUsage;
   }
 
-  /**
-   * The `GPUTextureUsage` flags this device creates textures with; injectable
-   * for the same reason as the buffer usage.
-   *
-   * @returns {object|null} The usage flags.
+  /**
+   * The `GPUTextureUsage` flags this device creates textures with; injectable
+   * for the same reason as the buffer usage.
+   *
+   * @returns {object|null} The usage flags.
    */
   GetTextureUsage() {
     return this._textureUsage;
   }
 
-  /**
-   * Returns the generation used to reject objects from earlier device
-   * lifecycles.
+  /**
+   * Returns the generation used to reject objects from earlier device
+   * lifecycles.
    */
   GetGeneration() {
     return this._generation;
   }
 
-  /**
-   * Returns the most recently accepted device-loss record, if any.
+  /**
+   * Returns the most recently accepted device-loss record, if any.
    */
   GetLostInfo() {
     return this._lostInfo;
   }
 
-  /**
-   * Reports whether the boundary is currently in the lost state.
+  /**
+   * Reports whether the boundary is currently in the lost state.
    */
   IsLost() {
     return this._state === "lost";
   }
 
-  /**
-   * Reports whether the boundary currently has a usable device.
+  /**
+   * Reports whether the boundary currently has a usable device.
    */
   IsReady() {
     return this._state === "ready";
   }
 
-  /**
-   * Compiles a Carbon WebGPU render descriptor and realizes its generation-bound
-   * canonical pipeline layout.
+  /**
+   * Compiles a Carbon WebGPU render descriptor and realizes its generation-bound
+   * canonical pipeline layout.
    */
   async PreparePipeline(pipeline, options = {}) {
     const descriptor = normalizePipeline(pipeline, this._shaderStage);
@@ -1062,9 +1130,9 @@ class CjsWebgpuDevice {
     }));
   }
 
-  /**
-   * Realizes a generation-bound native render pipeline from a Carbon WebGPU
-   * descriptor or prepared pipeline.
+  /**
+   * Realizes a generation-bound native render pipeline from a Carbon WebGPU
+   * descriptor or prepared pipeline.
    */
   async CreateRenderPipeline(pipelineOrPrepared, recipe) {
     const pipelineRecipe = validateRecipe(recipe);
@@ -1129,11 +1197,11 @@ class CjsWebgpuDevice {
     }));
   }
 
-  /**
-   * Upload an explicit CPU geometry payload into device-owned vertex/index
-   * buffers. The returned handle is opaque apart from its immutable
-   * caller-provided vertex layouts and lifecycle metadata; TriGeometryRes
-   * ownership remains outside the backend.
+  /**
+   * Upload an explicit CPU geometry payload into device-owned vertex/index
+   * buffers. The returned handle is opaque apart from its immutable
+   * caller-provided vertex layouts and lifecycle metadata; TriGeometryRes
+   * ownership remains outside the backend.
    */
   async CreateGeometry(options = {}) {
     this._AssertReady();
@@ -1247,8 +1315,8 @@ class CjsWebgpuDevice {
     });
   }
 
-  /**
-   * Destroys the device buffers owned by a geometry handle.
+  /**
+   * Destroys the device buffers owned by a geometry handle.
    */
   DestroyGeometry(geometry) {
     const record = GEOMETRIES.get(geometry);
@@ -1260,9 +1328,9 @@ class CjsWebgpuDevice {
     }
   }
 
-  /**
-   * Upload one explicit, single-mip, uncompressed 2D CPU texture payload.
-   * Sampler state and resource-path policy remain separate from this handle.
+  /**
+   * Upload one explicit, single-mip, uncompressed 2D CPU texture payload.
+   * Sampler state and resource-path policy remain separate from this handle.
    */
   async CreateTexture(options = {}) {
     this._AssertReady();
@@ -1404,8 +1472,8 @@ class CjsWebgpuDevice {
     });
   }
 
-  /**
-   * Destroys the native texture owned by a texture handle.
+  /**
+   * Destroys the native texture owned by a texture handle.
    */
   DestroyTexture(texture) {
     const record = TEXTURES.get(texture);
@@ -1415,10 +1483,10 @@ class CjsWebgpuDevice {
     if (typeof record.texture?.destroy === "function") record.texture.destroy();
   }
 
-  /**
-   * Normalize one explicit sampler descriptor and reuse its immutable native
-   * GPUSampler within this device generation. Each call receives an
-   * independently releasable opaque handle.
+  /**
+   * Normalize one explicit sampler descriptor and reuse its immutable native
+   * GPUSampler within this device generation. Each call receives an
+   * independently releasable opaque handle.
    */
   async CreateSampler(options = {}) {
     this._AssertReady();
@@ -1479,9 +1547,9 @@ class CjsWebgpuDevice {
     });
   }
 
-  /**
-   * Releases one logical sampler handle without destroying its shared native
-   * sampler.
+  /**
+   * Releases one logical sampler handle without destroying its shared native
+   * sampler.
    */
   DestroySampler(sampler) {
     const record = SAMPLERS.get(sampler);
@@ -1489,10 +1557,10 @@ class CjsWebgpuDevice {
     record.destroyed = true;
   }
 
-  /**
-   * Atomically realize one keyed collection of already-prepared plain GPU
-   * payloads. Child handles remain private until every queued creation has
-   * settled successfully, and the returned bundle owns their cleanup.
+  /**
+   * Atomically realize one keyed collection of already-prepared plain GPU
+   * payloads. Child handles remain private until every queued creation has
+   * settled successfully, and the returned bundle owns their cleanup.
    */
   async CreateResourceBundle(options = {}) {
     this._AssertReady();
@@ -1553,8 +1621,8 @@ class CjsWebgpuDevice {
     return bundle;
   }
 
-  /**
-   * Destroys a resource bundle's child handles in reverse creation order.
+  /**
+   * Destroys a resource bundle's child handles in reverse creation order.
    */
   DestroyResourceBundle(bundle) {
     const record = RESOURCE_BUNDLES.get(bundle);
@@ -1575,39 +1643,41 @@ class CjsWebgpuDevice {
     }
   }
 
-  /**
-   * Realize the already-published RGBA8 CPU payload attached to one resource.
-   * Mapping remains synchronous and GPU-free; allocation and guarded adapter
-   * publication are delegated to {@link CjsWebgpuDevice#_RealizeResource}.
-   * Concurrent calls for the same resource and adapter key share one operation.
-   *
-   * @param {CjsResource} resource Current loaded resource exposing `GetPayload()`.
-   * @param {object} options Texture key, bundle label, and adapter slot.
-   * @param {string} options.textureKey Binding/resource identity for the texture.
-   * @param {string} [options.bundleLabel="prepared RGBA8 texture"] Diagnostic bundle label.
-   * @param {string} [options.adapterKey="webgpu"] Resource adapter slot.
-   * @returns {Promise<object>} Engine-owned prepared resource bundle.
+  /**
+   * Realize the already-published RGBA8 CPU payload attached to one resource.
+   * Mapping remains synchronous and GPU-free; allocation and guarded adapter
+   * publication are delegated to {@link CjsWebgpuDevice#_RealizeResource}.
+   * Concurrent calls for the same resource and adapter key share one operation.
+   *
+   * @param {CjsResource} resource Current loaded resource exposing `GetPayload()`.
+   * @param {object} options Texture key, bundle label, and adapter slot.
+   * @param {string} options.textureKey Binding/resource identity for the texture.
+   * @param {string} [options.bundleLabel="prepared RGBA8 texture"] Diagnostic bundle label.
+   * @param {string} [options.adapterKey="webgpu"] Resource adapter slot.
+   * @returns {Promise<object>} Engine-owned prepared resource bundle.
    */
   RealizeRgba8Texture(resource, options = {}) {
     assertRealizationResource(resource);
     const plan = normalizeRgba8TextureRealizationOptions(options);
-    const input = mapRgba8TexturePayload(resource.GetPayload(), plan);
+    const payload = resource.GetPayload();
+    const bitmap = CjsSchema.cast(payload, HostBitmap);
+    const input = bitmap ? mapRgba8TextureBitmap(bitmap, plan) : mapRgba8TexturePayload(payload, plan);
     return this.RealizeResource(resource, input, {
       adapterKey: plan.adapterKey
     });
   }
 
-  /**
-   * Realize already-selected WebGPU sampler state from a published CPU payload.
-   * Selection and texture pairing remain caller policy; this method only maps,
-   * allocates, and commits the selected sampler under the requested adapter key.
-   *
-   * @param {CjsResource} resource Current loaded resource exposing `GetPayload()`.
-   * @param {object} options Sampler key, bundle label, and adapter slot.
-   * @param {string} options.samplerKey Binding/resource identity for the sampler.
-   * @param {string} [options.bundleLabel="prepared WebGPU sampler"] Diagnostic bundle label.
-   * @param {string} [options.adapterKey="webgpu"] Resource adapter slot.
-   * @returns {Promise<object>} Engine-owned prepared resource bundle.
+  /**
+   * Realize already-selected WebGPU sampler state from a published CPU payload.
+   * Selection and texture pairing remain caller policy; this method only maps,
+   * allocates, and commits the selected sampler under the requested adapter key.
+   *
+   * @param {CjsResource} resource Current loaded resource exposing `GetPayload()`.
+   * @param {object} options Sampler key, bundle label, and adapter slot.
+   * @param {string} options.samplerKey Binding/resource identity for the sampler.
+   * @param {string} [options.bundleLabel="prepared WebGPU sampler"] Diagnostic bundle label.
+   * @param {string} [options.adapterKey="webgpu"] Resource adapter slot.
+   * @returns {Promise<object>} Engine-owned prepared resource bundle.
    */
   RealizeSampler(resource, options = {}) {
     assertRealizationResource(resource);
@@ -1618,20 +1688,20 @@ class CjsWebgpuDevice {
     });
   }
 
-  /**
-   * Realize one already-published CPU resource as an engine-owned WebGPU bundle.
-   *
-   * The in-flight boundary is this device session plus resource handle and
-   * adapter key. Candidate allocation completes before a synchronous current-
-   * target check and adapter commit. A stale or failed candidate is destroyed;
-   * a current failure restores any usable prior adapter and otherwise returns
-   * the resource to `LOADED` without discarding its CPU payload.
-   *
-   * @param {CjsResource} resource Current loaded resource receiving the adapter.
-   * @param {object} value Plain geometry/texture/sampler bundle input. When omitted, the resource payload is used.
-   * @param {object} [options={}] Adapter publication options.
-   * @param {string} [options.adapterKey="webgpu"] Resource adapter slot.
-   * @returns {Promise<object>} Engine-owned prepared resource bundle.
+  /**
+   * Realize one already-published CPU resource as an engine-owned WebGPU bundle.
+   *
+   * The in-flight boundary is this device session plus resource handle and
+   * adapter key. Candidate allocation completes before a synchronous current-
+   * target check and adapter commit. A stale or failed candidate is destroyed;
+   * a current failure restores any usable prior adapter and otherwise returns
+   * the resource to `LOADED` without discarding its CPU payload.
+   *
+   * @param {CjsResource} resource Current loaded resource receiving the adapter.
+   * @param {object} value Plain geometry/texture/sampler bundle input. When omitted, the resource payload is used.
+   * @param {object} [options={}] Adapter publication options.
+   * @param {string} [options.adapterKey="webgpu"] Resource adapter slot.
+   * @returns {Promise<object>} Engine-owned prepared resource bundle.
    */
   RealizeResource(resource, value, options = {}) {
     assertRealizationResource(resource);
@@ -1653,8 +1723,8 @@ class CjsWebgpuDevice {
     return promise;
   }
 
-  /**
-   * Allocates, publishes, and rolls back one guarded resource realization.
+  /**
+   * Allocates, publishes, and rolls back one guarded resource realization.
    */
   async _RealizeResource(resource, value, plan) {
     const stale = () => {
@@ -1724,9 +1794,9 @@ class CjsWebgpuDevice {
     }
   }
 
-  /**
-   * Creates generation-bound bind groups and owned uniform buffers for a live
-   * pipeline.
+  /**
+   * Creates generation-bound bind groups and owned uniform buffers for a live
+   * pipeline.
    */
   CreateBindingSet(livePipeline, options = {}) {
     const record = assertLive(this, livePipeline);
@@ -1862,13 +1932,13 @@ class CjsWebgpuDevice {
   // The handle is opaque and the `GPUBuffer` stays in DEVICE_BUFFERS, matching
   // how geometries and binding sets are held here.
 
-  /**
-   * Creates a buffer whose contents the caller rewrites.
-   *
-   * @param {object} options `{ label, size, usage }` - usage is a raw
-   *   `GPUBufferUsage` mask; COPY_DST is added because writes arrive through
-   *   `WriteDeviceBuffer`.
-   * @returns {object} An opaque handle carrying `size` and `Destroy`.
+  /**
+   * Creates a buffer whose contents the caller rewrites.
+   *
+   * @param {object} options `{ label, size, usage }` - usage is a raw
+   *   `GPUBufferUsage` mask; COPY_DST is added because writes arrive through
+   *   `WriteDeviceBuffer`.
+   * @returns {object} An opaque handle carrying `size` and `Destroy`.
    */
   CreateDeviceBuffer({
     label = "device-buffer",
@@ -1907,13 +1977,13 @@ class CjsWebgpuDevice {
     return handle;
   }
 
-  /**
-   * Uploads bytes into a device buffer.
-   *
-   * @param {object} handle A `CreateDeviceBuffer` handle.
-   * @param {ArrayBufferView} bytes The bytes to write.
-   * @param {number} [offset] Byte offset into the buffer.
-   * @returns {object} The handle.
+  /**
+   * Uploads bytes into a device buffer.
+   *
+   * @param {object} handle A `CreateDeviceBuffer` handle.
+   * @param {ArrayBufferView} bytes The bytes to write.
+   * @param {number} [offset] Byte offset into the buffer.
+   * @returns {object} The handle.
    */
   WriteDeviceBuffer(handle, bytes, offset = 0) {
     const record = DEVICE_BUFFERS.get(handle);
@@ -1926,11 +1996,11 @@ class CjsWebgpuDevice {
     return handle;
   }
 
-  /**
-   * The `GPUBuffer` behind a handle, for binding it to a draw.
-   *
-   * @param {object} handle A `CreateDeviceBuffer` handle.
-   * @returns {GPUBuffer} The buffer.
+  /**
+   * The `GPUBuffer` behind a handle, for binding it to a draw.
+   *
+   * @param {object} handle A `CreateDeviceBuffer` handle.
+   * @returns {GPUBuffer} The buffer.
    */
   GetDeviceBuffer(handle) {
     const record = DEVICE_BUFFERS.get(handle);
@@ -1938,9 +2008,9 @@ class CjsWebgpuDevice {
     return record.buffer;
   }
 
-  /**
-   * Validates and uploads exact-size updates to a binding set's owned uniform
-   * buffers.
+  /**
+   * Validates and uploads exact-size updates to a binding set's owned uniform
+   * buffers.
    */
   UpdateBindingSet(bindingSet, uniformData) {
     const record = assertBindingSet(this, bindingSet);
@@ -1961,9 +2031,9 @@ class CjsWebgpuDevice {
     return bindingSet;
   }
 
-  /**
-   * Destroys a binding set's owned uniform buffers without releasing external
-   * resources.
+  /**
+   * Destroys a binding set's owned uniform buffers without releasing external
+   * resources.
    */
   DestroyBindingSet(bindingSet) {
     const record = BINDING_SETS.get(bindingSet);
@@ -1975,8 +2045,8 @@ class CjsWebgpuDevice {
     }
   }
 
-  /**
-   * Validates and snapshots one generation-bound indexed or non-indexed draw.
+  /**
+   * Validates and snapshots one generation-bound indexed or non-indexed draw.
    */
   CreateDraw(livePipeline, options = {}) {
     const record = assertLive(this, livePipeline);
@@ -2130,17 +2200,17 @@ class CjsWebgpuDevice {
     return draw;
   }
 
-  /**
-   * Encodes one validated draw into a render pass.
-   *
-   * An optional `state` is a CjsWebgpuEncodeState the CALLER owns for the
-   * lifetime of one render pass. When supplied, a set whose value is already
-   * bound is skipped - Carbon's DX11 path does the same redundancy compare on
-   * its shader program and its three state caches. Omitting it sets
-   * everything, which is always correct and is what an unrelated caller gets.
-   *
-   * Deciding WHICH batches may share is not this method's business; that is
-   * the dispatcher's grouping. This only honours a decision already made.
+  /**
+   * Encodes one validated draw into a render pass.
+   *
+   * An optional `state` is a CjsWebgpuEncodeState the CALLER owns for the
+   * lifetime of one render pass. When supplied, a set whose value is already
+   * bound is skipped - Carbon's DX11 path does the same redundancy compare on
+   * its shader program and its three state caches. Omitting it sets
+   * everything, which is always correct and is what an unrelated caller gets.
+   *
+   * Deciding WHICH batches may share is not this method's business; that is
+   * the dispatcher's grouping. This only honours a decision already made.
    */
   EncodeDraw(pass, draw, state = null) {
     const wrapper = DRAWS.get(draw);
@@ -2190,16 +2260,16 @@ class CjsWebgpuDevice {
     }
   }
 
-  /**
-   * Submits command buffers to the ready device queue.
+  /**
+   * Submits command buffers to the ready device queue.
    */
   Submit(commandBuffers) {
     this.GetDevice().queue.submit(commandBuffers);
   }
 
-  /**
-   * Acquires or accepts a replacement adapter/device and advances the device
-   * generation.
+  /**
+   * Acquires or accepts a replacement adapter/device and advances the device
+   * generation.
    */
   async Recreate(options = {}) {
     if (this._state === "destroyed") fail("cannot recreate a destroyed device");
@@ -2234,9 +2304,9 @@ class CjsWebgpuDevice {
     return this;
   }
 
-  /**
-   * Transitions the boundary to destroyed, invalidates its generation, and
-   * destroys the native device.
+  /**
+   * Transitions the boundary to destroyed, invalidates its generation, and
+   * destroys the native device.
    */
   Destroy() {
     if (this._state === "destroyed") return;
@@ -2252,24 +2322,24 @@ class CjsWebgpuDevice {
     if (typeof device?.destroy === "function") device.destroy();
   }
 
-  /**
-   * Throws unless the boundary has a ready native device.
+  /**
+   * Throws unless the boundary has a ready native device.
    */
   _AssertReady() {
     if (this._state !== "ready" || !this._device) fail(`device is ${this._state}`);
   }
 
-  /**
-   * Throws unless an object generation matches the current ready device.
+  /**
+   * Throws unless an object generation matches the current ready device.
    */
   _AssertGeneration(generation) {
     this._AssertReady();
     if (generation !== this._generation) fail(`object belongs to stale device generation ${generation}`);
   }
 
-  /**
-   * Queues a validation-sensitive operation after all previously queued
-   * operations settle.
+  /**
+   * Queues a validation-sensitive operation after all previously queued
+   * operations settle.
    */
   _SerializeValidation(operation) {
     const run = this._validationTail.then(operation, operation);
@@ -2277,9 +2347,9 @@ class CjsWebgpuDevice {
     return run;
   }
 
-  /**
-   * Tracks loss for one device generation and accepts only a still-current
-   * loss event.
+  /**
+   * Tracks loss for one device generation and accepts only a still-current
+   * loss event.
    */
   _WatchDevice(device, generation) {
     if (!device?.lost || typeof device.lost.then !== "function") return;