@simulatte/webgpu 0.3.1 → 0.3.2

package/src/runtime_cli.js

@@ -11,7 +11,7 @@ const LIB_EXTENSION_BY_PLATFORM = {
 
 const WORKSPACE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
 
-function first_existing_path(paths) {
+function firstExistingPath(paths) {
     for (const path of paths) {
         if (!path) continue;
         if (existsSync(path)) return path;
@@ -19,7 +19,7 @@ function first_existing_path(paths) {
     return null;
 }
 
-function require_existing_path(label, path) {
+function requireExistingPath(label, path) {
     if (!path) {
         throw new Error(`Missing ${label}.`);
     }
@@ -28,7 +28,7 @@ function require_existing_path(label, path) {
     }
 }
 
-function run_process(command, args, spawn_options = {}) {
+function runProcess(command, args, spawn_options = {}) {
     const result = spawnSync(command, args, {
         encoding: "utf8",
         ...spawn_options,
@@ -44,13 +44,13 @@ function run_process(command, args, spawn_options = {}) {
     };
 }
 
-function read_trace_meta(path) {
+function readTraceMeta(path) {
     if (!path || !existsSync(path)) return null;
     const raw = readFileSync(path, "utf8");
     return JSON.parse(raw);
 }
 
-function build_bench_args(options) {
+function buildBenchArgs(options) {
     const args = ["--commands", options.commandsPath];
     if (options.quirksPath) args.push("--quirks", options.quirksPath);
     if (options.vendor) args.push("--vendor", options.vendor);
@@ -72,12 +72,12 @@ function build_bench_args(options) {
     return args;
 }
 
-function has_option_flag(args, flag) {
+function hasOptionFlag(args, flag) {
     return Array.isArray(args) && args.includes(flag);
 }
 
 export function resolveFawnRepoRoot(explicitPath) {
-    const resolved = first_existing_path([
+    const resolved = firstExistingPath([
         explicitPath ? resolve(explicitPath, "bench/compare_dawn_vs_doe.py") : null,
         resolve(process.cwd(), "bench/compare_dawn_vs_doe.py"),
         resolve(WORKSPACE_ROOT, "bench/compare_dawn_vs_doe.py"),
@@ -91,7 +91,7 @@ export function resolveFawnRepoRoot(explicitPath) {
 }
 
 export function resolveDoeBinaryPath(explicitPath) {
-    const resolved = first_existing_path([
+    const resolved = firstExistingPath([
         explicitPath,
         process.env.FAWN_DOE_BIN,
         resolve(process.cwd(), "zig/zig-out/bin/doe-zig-runtime"),
@@ -107,7 +107,7 @@ export function resolveDoeBinaryPath(explicitPath) {
 
 export function resolveDoeLibraryPath(explicitPath) {
     const preferredExt = LIB_EXTENSION_BY_PLATFORM[process.platform] ?? "so";
-    return first_existing_path([
+    return firstExistingPath([
         explicitPath,
         process.env.FAWN_DOE_LIB,
         resolve(process.cwd(), `zig/zig-out/lib/libwebgpu_doe.${preferredExt}`),
@@ -122,7 +122,7 @@ export function resolveDoeLibraryPath(explicitPath) {
 }
 
 export function resolveCompareScriptPath(explicitPath, repoRoot = null) {
-    const resolved = first_existing_path([
+    const resolved = firstExistingPath([
         explicitPath,
         repoRoot ? resolve(repoRoot, "bench/compare_dawn_vs_doe.py") : null,
         resolve(process.cwd(), "bench/compare_dawn_vs_doe.py"),
@@ -145,7 +145,7 @@ export function createDoeRuntime(options = {}) {
         if (libPath) {
             env.FAWN_DOE_LIB = libPath;
         }
-        return run_process(binPath, args, {
+        return runProcess(binPath, args, {
             ...spawnOptions,
             env,
         });
@@ -155,13 +155,13 @@ export function createDoeRuntime(options = {}) {
         if (!runOptions || typeof runOptions !== "object") {
             throw new Error("runBench requires an options object.");
         }
-        require_existing_path("commandsPath", runOptions.commandsPath);
-        if (runOptions.quirksPath) require_existing_path("quirksPath", runOptions.quirksPath);
-        const args = build_bench_args(runOptions);
+        requireExistingPath("commandsPath", runOptions.commandsPath);
+        if (runOptions.quirksPath) requireExistingPath("quirksPath", runOptions.quirksPath);
+        const args = buildBenchArgs(runOptions);
         const result = runRaw(args, {
             cwd: runOptions.cwd || WORKSPACE_ROOT,
         });
-        const traceMeta = read_trace_meta(runOptions.traceMetaPath);
+        const traceMeta = readTraceMeta(runOptions.traceMetaPath);
         return {
             ...result,
             traceJsonlPath: runOptions.traceJsonlPath ?? null,
@@ -193,11 +193,11 @@ export function runDawnVsDoeCompare(options = {}) {
     }
     args.push(...extraArgs);
 
-    if (!options.configPath && !has_option_flag(extraArgs, "--config")) {
+    if (!options.configPath && !hasOptionFlag(extraArgs, "--config")) {
         throw new Error("runDawnVsDoeCompare requires configPath or --config in extraArgs.");
     }
 
-    return run_process(pythonBin, args, {
+    return runProcess(pythonBin, args, {
         cwd: repoRoot,
         env: { ...process.env, ...(options.env ?? {}) },
     });

package/src/shared/capabilities.js

@@ -0,0 +1,144 @@
+const FEATURE_DEPTH_CLIP_CONTROL = 0x00000001;
+const FEATURE_DEPTH32FLOAT_STENCIL8 = 0x00000002;
+const FEATURE_TEXTURE_COMPRESSION_BC = 0x00000003;
+const FEATURE_TEXTURE_COMPRESSION_BC_SLICED_3D = 0x00000004;
+const FEATURE_TEXTURE_COMPRESSION_ETC2 = 0x00000005;
+const FEATURE_TEXTURE_COMPRESSION_ASTC = 0x00000006;
+const FEATURE_TEXTURE_COMPRESSION_ASTC_SLICED_3D = 0x00000007;
+const FEATURE_RG11B10UFLOAT_RENDERABLE = 0x00000008;
+const FEATURE_TIMESTAMP_QUERY = 0x00000009;
+const FEATURE_BGRA8UNORM_STORAGE = 0x0000000A;
+const FEATURE_SHADER_F16 = 0x0000000B;
+const FEATURE_INDIRECT_FIRST_INSTANCE = 0x0000000C;
+const FEATURE_FLOAT32_FILTERABLE = 0x0000000D;
+const FEATURE_SUBGROUPS = 0x0000000E;
+const FEATURE_SUBGROUPS_F16 = 0x0000000F;
+const FEATURE_FLOAT32_BLENDABLE = 0x00000010;
+const FEATURE_CLIP_DISTANCES = 0x00000011;
+const FEATURE_DUAL_SOURCE_BLENDING = 0x00000012;
+
+const SHADER_F16_FEATURE = FEATURE_SHADER_F16;
+
+const KNOWN_FEATURES = Object.freeze([
+  ['depth-clip-control', FEATURE_DEPTH_CLIP_CONTROL],
+  ['depth32float-stencil8', FEATURE_DEPTH32FLOAT_STENCIL8],
+  ['texture-compression-bc', FEATURE_TEXTURE_COMPRESSION_BC],
+  ['texture-compression-bc-sliced-3d', FEATURE_TEXTURE_COMPRESSION_BC_SLICED_3D],
+  ['texture-compression-etc2', FEATURE_TEXTURE_COMPRESSION_ETC2],
+  ['texture-compression-astc', FEATURE_TEXTURE_COMPRESSION_ASTC],
+  ['texture-compression-astc-sliced-3d', FEATURE_TEXTURE_COMPRESSION_ASTC_SLICED_3D],
+  ['rg11b10ufloat-renderable', FEATURE_RG11B10UFLOAT_RENDERABLE],
+  ['timestamp-query', FEATURE_TIMESTAMP_QUERY],
+  ['bgra8unorm-storage', FEATURE_BGRA8UNORM_STORAGE],
+  ['shader-f16', FEATURE_SHADER_F16],
+  ['indirect-first-instance', FEATURE_INDIRECT_FIRST_INSTANCE],
+  ['float32-filterable', FEATURE_FLOAT32_FILTERABLE],
+  ['subgroups', FEATURE_SUBGROUPS],
+  ['subgroups-f16', FEATURE_SUBGROUPS_F16],
+  ['float32-blendable', FEATURE_FLOAT32_BLENDABLE],
+  ['clip-distances', FEATURE_CLIP_DISTANCES],
+  ['dual-source-blending', FEATURE_DUAL_SOURCE_BLENDING],
+]);
+
+const DOE_LIMITS = Object.freeze({
+  maxTextureDimension1D: 16384,
+  maxTextureDimension2D: 16384,
+  maxTextureDimension3D: 2048,
+  maxTextureArrayLayers: 2048,
+  maxBindGroups: 4,
+  maxBindGroupsPlusVertexBuffers: 24,
+  maxBindingsPerBindGroup: 1000,
+  maxDynamicUniformBuffersPerPipelineLayout: 8,
+  maxDynamicStorageBuffersPerPipelineLayout: 4,
+  maxSampledTexturesPerShaderStage: 16,
+  maxSamplersPerShaderStage: 16,
+  maxStorageBuffersPerShaderStage: 8,
+  maxStorageTexturesPerShaderStage: 4,
+  maxUniformBuffersPerShaderStage: 12,
+  maxUniformBufferBindingSize: 65536,
+  maxStorageBufferBindingSize: 134217728,
+  minUniformBufferOffsetAlignment: 256,
+  minStorageBufferOffsetAlignment: 32,
+  maxVertexBuffers: 8,
+  maxBufferSize: 268435456,
+  maxVertexAttributes: 16,
+  maxVertexBufferArrayStride: 2048,
+  maxInterStageShaderVariables: 16,
+  maxColorAttachments: 8,
+  maxColorAttachmentBytesPerSample: 32,
+  maxComputeWorkgroupStorageSize: 32768,
+  maxComputeInvocationsPerWorkgroup: 1024,
+  maxComputeWorkgroupSizeX: 1024,
+  maxComputeWorkgroupSizeY: 1024,
+  maxComputeWorkgroupSizeZ: 64,
+  maxComputeWorkgroupsPerDimension: 65535,
+});
+
+const DOE_LIMIT_NAMES = Object.freeze(Object.keys(DOE_LIMITS));
+const DOE_FEATURES = Object.freeze(new Set());
+
+function featureSet(hasFeature) {
+  const supported = [];
+  for (const [name, value] of KNOWN_FEATURES) {
+    if (hasFeature(value)) supported.push(name);
+  }
+  return supported.length === 0 ? DOE_FEATURES : Object.freeze(new Set(supported));
+}
+
+function isPublishedLimitValue(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+
+function publishLimits(queried) {
+  if (!queried || typeof queried !== 'object') {
+    return DOE_LIMITS;
+  }
+  let sawNativeValue = false;
+  const published = {};
+  for (const name of DOE_LIMIT_NAMES) {
+    const value = queried[name];
+    if (isPublishedLimitValue(value)) {
+      published[name] = value;
+      sawNativeValue = true;
+      continue;
+    }
+    published[name] = DOE_LIMITS[name];
+  }
+  return sawNativeValue ? Object.freeze(published) : DOE_LIMITS;
+}
+
+function publishFeatures(hasFeature) {
+  if (typeof hasFeature !== 'function') {
+    return DOE_FEATURES;
+  }
+  return featureSet(hasFeature);
+}
+
+export {
+  FEATURE_DEPTH_CLIP_CONTROL,
+  FEATURE_DEPTH32FLOAT_STENCIL8,
+  FEATURE_TEXTURE_COMPRESSION_BC,
+  FEATURE_TEXTURE_COMPRESSION_BC_SLICED_3D,
+  FEATURE_TEXTURE_COMPRESSION_ETC2,
+  FEATURE_TEXTURE_COMPRESSION_ASTC,
+  FEATURE_TEXTURE_COMPRESSION_ASTC_SLICED_3D,
+  FEATURE_RG11B10UFLOAT_RENDERABLE,
+  FEATURE_TIMESTAMP_QUERY,
+  FEATURE_BGRA8UNORM_STORAGE,
+  FEATURE_SHADER_F16,
+  FEATURE_INDIRECT_FIRST_INSTANCE,
+  FEATURE_FLOAT32_FILTERABLE,
+  FEATURE_SUBGROUPS,
+  FEATURE_SUBGROUPS_F16,
+  FEATURE_FLOAT32_BLENDABLE,
+  FEATURE_CLIP_DISTANCES,
+  FEATURE_DUAL_SOURCE_BLENDING,
+  SHADER_F16_FEATURE,
+  KNOWN_FEATURES,
+  DOE_LIMITS,
+  DOE_LIMIT_NAMES,
+  DOE_FEATURES,
+  featureSet,
+  publishLimits,
+  publishFeatures,
+};

package/src/shared/compiler-errors.js

@@ -0,0 +1,78 @@
+function shaderCheckFailure(path, result) {
+  const stage = typeof result?.stage === 'string' && result.stage.length > 0 ? result.stage : 'unknown';
+  const kind = typeof result?.kind === 'string' && result.kind.length > 0 ? result.kind : 'ShaderCheckFailed';
+  const message = typeof result?.message === 'string' && result.message.length > 0
+    ? result.message
+    : 'shader check failed without native detail';
+  const error = new Error(`${path}: ${message}`);
+  error.code = kind;
+  error.stage = stage;
+  if (typeof result?.line === 'number' && result.line > 0) {
+    error.line = result.line;
+  }
+  if (typeof result?.column === 'number' && result.column > 0) {
+    error.column = result.column;
+  }
+  throw error;
+}
+
+/**
+ * Attach structured compiler error fields to a native error object.
+ *
+ * Prefers structured `fields` (stage, kind, line, column) from the native ABI
+ * over regex parsing of the message string. Falls back to regex when `fields`
+ * is not provided, for compatibility with older native layers that do not
+ * export `doeNativeGetLastErrorLine` / `doeNativeGetLastErrorColumn`.
+ *
+ * @param {Error} error - The thrown error from the native call.
+ * @param {string} path - The WebGPU API path label (e.g. "GPUDevice.createShaderModule").
+ * @param {{ stage?: string, kind?: string, line?: number, column?: number } | null} [fields]
+ *   Optional structured fields from the native ABI. When provided, skips regex parsing.
+ */
+function enrichNativeCompilerError(error, path, fields = null) {
+  if (!(error instanceof Error)) return error;
+  if (fields !== null && typeof fields === 'object') {
+    if (typeof fields.stage === 'string' && fields.stage.length > 0) {
+      error.stage = fields.stage;
+    }
+    if (typeof fields.kind === 'string' && fields.kind.length > 0) {
+      error.kind = fields.kind;
+      if (!error.code || error.code === 'DOE_ERROR') {
+        error.code = fields.kind;
+      }
+    }
+    if (typeof fields.line === 'number' && fields.line > 0) {
+      error.line = fields.line;
+    }
+    if (typeof fields.column === 'number' && fields.column > 0) {
+      error.column = fields.column;
+    }
+    // Prefix the message with the API path but leave the body intact.
+    const bodyMatch = /^\[([A-Za-z0-9_]+)(?:\/([A-Za-z0-9_]+))?\]\s+([\s\S]+)$/.exec(error.message);
+    error.message = `${path}: ${bodyMatch ? bodyMatch[3] : error.message}`;
+    return error;
+  }
+  // Fallback: parse [stage/kind] prefix from the message string.
+  const match = /^\[([A-Za-z0-9_]+)(?:\/([A-Za-z0-9_]+))?\]\s+([\s\S]+)$/.exec(error.message);
+  if (match) {
+    error.stage = match[1];
+    if (match[2]) {
+      error.kind = match[2];
+      if (!error.code || error.code === 'DOE_ERROR') {
+        error.code = match[2];
+      }
+    }
+    error.message = `${path}: ${match[3]}`;
+  }
+  return error;
+}
+
+function compilerErrorFromMessage(path, message, fields = null) {
+  return enrichNativeCompilerError(new Error(message), path, fields);
+}
+
+export {
+  shaderCheckFailure,
+  enrichNativeCompilerError,
+  compilerErrorFromMessage,
+};

package/src/shared/encoder-surface.js

@@ -0,0 +1,295 @@
+import {
+  UINT32_MAX,
+  failValidation,
+  initResource,
+  assertObject,
+  assertIntegerInRange,
+  assertLiveResource,
+} from './resource-lifecycle.js';
+
+function createEncoderClasses(backend) {
+  let classes = null;
+
+  class DoeGPUComputePassEncoder {
+    constructor(state, encoder) {
+      this._encoder = encoder;
+      initResource(this, 'GPUComputePassEncoder', encoder);
+      backend.computePassInit(this, state);
+    }
+
+    _assertOpen(path) {
+      if (typeof backend.computePassAssertOpen === 'function') {
+        backend.computePassAssertOpen(this, path);
+      }
+    }
+
+    setPipeline(pipeline) {
+      this._assertOpen('GPUComputePassEncoder.setPipeline');
+      backend.computePassSetPipeline(
+        this,
+        assertLiveResource(pipeline, 'GPUComputePassEncoder.setPipeline', 'GPUComputePipeline'),
+      );
+    }
+
+    setBindGroup(index, bindGroup) {
+      this._assertOpen('GPUComputePassEncoder.setBindGroup');
+      assertIntegerInRange(index, 'GPUComputePassEncoder.setBindGroup', 'index', { min: 0, max: UINT32_MAX });
+      backend.computePassSetBindGroup(
+        this,
+        index,
+        assertLiveResource(bindGroup, 'GPUComputePassEncoder.setBindGroup', 'GPUBindGroup'),
+      );
+    }
+
+    dispatchWorkgroups(x, y = 1, z = 1) {
+      this._assertOpen('GPUComputePassEncoder.dispatchWorkgroups');
+      assertIntegerInRange(x, 'GPUComputePassEncoder.dispatchWorkgroups', 'x', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(y, 'GPUComputePassEncoder.dispatchWorkgroups', 'y', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(z, 'GPUComputePassEncoder.dispatchWorkgroups', 'z', { min: 0, max: UINT32_MAX });
+      backend.computePassDispatchWorkgroups(this, x, y, z);
+    }
+
+    dispatchWorkgroupsIndirect(indirectBuffer, indirectOffset = 0) {
+      this._assertOpen('GPUComputePassEncoder.dispatchWorkgroupsIndirect');
+      assertIntegerInRange(indirectOffset, 'GPUComputePassEncoder.dispatchWorkgroupsIndirect', 'indirectOffset', { min: 0 });
+      backend.computePassDispatchWorkgroupsIndirect(
+        this,
+        assertLiveResource(indirectBuffer, 'GPUComputePassEncoder.dispatchWorkgroupsIndirect', 'GPUBuffer'),
+        indirectOffset,
+      );
+    }
+
+    end() {
+      this._assertOpen('GPUComputePassEncoder.end');
+      backend.computePassEnd(this);
+    }
+  }
+
+  class DoeGPURenderPassEncoder {
+    constructor(state, encoder) {
+      this._encoder = encoder;
+      initResource(this, 'GPURenderPassEncoder', encoder);
+      backend.renderPassInit(this, state);
+    }
+
+    _assertOpen(path) {
+      if (typeof backend.renderPassAssertOpen === 'function') {
+        backend.renderPassAssertOpen(this, path);
+      }
+    }
+
+    setPipeline(pipeline) {
+      this._assertOpen('GPURenderPassEncoder.setPipeline');
+      backend.renderPassSetPipeline(
+        this,
+        assertLiveResource(pipeline, 'GPURenderPassEncoder.setPipeline', 'GPURenderPipeline'),
+      );
+    }
+
+    setBindGroup(index, bindGroup) {
+      this._assertOpen('GPURenderPassEncoder.setBindGroup');
+      assertIntegerInRange(index, 'GPURenderPassEncoder.setBindGroup', 'index', { min: 0, max: UINT32_MAX });
+      backend.renderPassSetBindGroup(
+        this,
+        index,
+        assertLiveResource(bindGroup, 'GPURenderPassEncoder.setBindGroup', 'GPUBindGroup'),
+      );
+    }
+
+    setVertexBuffer(slot, buffer, offset = 0, size) {
+      this._assertOpen('GPURenderPassEncoder.setVertexBuffer');
+      assertIntegerInRange(slot, 'GPURenderPassEncoder.setVertexBuffer', 'slot', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(offset, 'GPURenderPassEncoder.setVertexBuffer', 'offset', { min: 0 });
+      if (size !== undefined) {
+        assertIntegerInRange(size, 'GPURenderPassEncoder.setVertexBuffer', 'size', { min: 0 });
+      }
+      backend.renderPassSetVertexBuffer(
+        this,
+        slot,
+        assertLiveResource(buffer, 'GPURenderPassEncoder.setVertexBuffer', 'GPUBuffer'),
+        offset,
+        size,
+      );
+    }
+
+    setIndexBuffer(buffer, format, offset = 0, size) {
+      this._assertOpen('GPURenderPassEncoder.setIndexBuffer');
+      assertIntegerInRange(offset, 'GPURenderPassEncoder.setIndexBuffer', 'offset', { min: 0 });
+      if (size !== undefined) {
+        assertIntegerInRange(size, 'GPURenderPassEncoder.setIndexBuffer', 'size', { min: 0 });
+      }
+      backend.renderPassSetIndexBuffer(
+        this,
+        assertLiveResource(buffer, 'GPURenderPassEncoder.setIndexBuffer', 'GPUBuffer'),
+        format,
+        offset,
+        size,
+      );
+    }
+
+    draw(vertexCount, instanceCount = 1, firstVertex = 0, firstInstance = 0) {
+      this._assertOpen('GPURenderPassEncoder.draw');
+      assertIntegerInRange(vertexCount, 'GPURenderPassEncoder.draw', 'vertexCount', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(instanceCount, 'GPURenderPassEncoder.draw', 'instanceCount', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(firstVertex, 'GPURenderPassEncoder.draw', 'firstVertex', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(firstInstance, 'GPURenderPassEncoder.draw', 'firstInstance', { min: 0, max: UINT32_MAX });
+      backend.renderPassDraw(this, vertexCount, instanceCount, firstVertex, firstInstance);
+    }
+
+    drawIndexed(indexCount, instanceCount = 1, firstIndex = 0, baseVertex = 0, firstInstance = 0) {
+      this._assertOpen('GPURenderPassEncoder.drawIndexed');
+      assertIntegerInRange(indexCount, 'GPURenderPassEncoder.drawIndexed', 'indexCount', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(instanceCount, 'GPURenderPassEncoder.drawIndexed', 'instanceCount', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(firstIndex, 'GPURenderPassEncoder.drawIndexed', 'firstIndex', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(firstInstance, 'GPURenderPassEncoder.drawIndexed', 'firstInstance', { min: 0, max: UINT32_MAX });
+      backend.renderPassDrawIndexed(this, indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+    }
+
+    drawIndirect(indirectBuffer, indirectOffset = 0) {
+      this._assertOpen('GPURenderPassEncoder.drawIndirect');
+      assertIntegerInRange(indirectOffset, 'GPURenderPassEncoder.drawIndirect', 'indirectOffset', { min: 0 });
+      backend.renderPassDrawIndirect(
+        this,
+        assertLiveResource(indirectBuffer, 'GPURenderPassEncoder.drawIndirect', 'GPUBuffer'),
+        indirectOffset,
+      );
+    }
+
+    drawIndexedIndirect(indirectBuffer, indirectOffset = 0) {
+      this._assertOpen('GPURenderPassEncoder.drawIndexedIndirect');
+      assertIntegerInRange(indirectOffset, 'GPURenderPassEncoder.drawIndexedIndirect', 'indirectOffset', { min: 0 });
+      backend.renderPassDrawIndexedIndirect(
+        this,
+        assertLiveResource(indirectBuffer, 'GPURenderPassEncoder.drawIndexedIndirect', 'GPUBuffer'),
+        indirectOffset,
+      );
+    }
+
+    end() {
+      this._assertOpen('GPURenderPassEncoder.end');
+      backend.renderPassEnd(this);
+    }
+  }
+
+  class DoeGPUCommandEncoder {
+    constructor(state, device) {
+      this._device = device;
+      initResource(this, 'GPUCommandEncoder', device);
+      backend.commandEncoderInit(this, state);
+    }
+
+    _assertOpen(path) {
+      assertLiveResource(this._device, path, 'GPUDevice');
+      if (typeof backend.commandEncoderAssertOpen === 'function') {
+        backend.commandEncoderAssertOpen(this, path);
+      }
+    }
+
+    beginComputePass(descriptor) {
+      this._assertOpen('GPUCommandEncoder.beginComputePass');
+      return backend.commandEncoderBeginComputePass(this, descriptor, classes);
+    }
+
+    beginRenderPass(descriptor) {
+      this._assertOpen('GPUCommandEncoder.beginRenderPass');
+      const passDescriptor = assertObject(descriptor, 'GPUCommandEncoder.beginRenderPass', 'descriptor');
+      return backend.commandEncoderBeginRenderPass(this, passDescriptor, classes);
+    }
+
+    copyBufferToBuffer(src, srcOffset, dst, dstOffset, size) {
+      this._assertOpen('GPUCommandEncoder.copyBufferToBuffer');
+      assertIntegerInRange(srcOffset, 'GPUCommandEncoder.copyBufferToBuffer', 'srcOffset', { min: 0 });
+      assertIntegerInRange(dstOffset, 'GPUCommandEncoder.copyBufferToBuffer', 'dstOffset', { min: 0 });
+      assertIntegerInRange(size, 'GPUCommandEncoder.copyBufferToBuffer', 'size', { min: 1 });
+      backend.commandEncoderCopyBufferToBuffer(
+        this,
+        assertLiveResource(src, 'GPUCommandEncoder.copyBufferToBuffer', 'GPUBuffer'),
+        srcOffset,
+        assertLiveResource(dst, 'GPUCommandEncoder.copyBufferToBuffer', 'GPUBuffer'),
+        dstOffset,
+        size,
+      );
+    }
+
+    copyTextureToBuffer(source, destination, copySize) {
+      this._assertOpen('GPUCommandEncoder.copyTextureToBuffer');
+      const sourceObject = assertObject(source, 'GPUCommandEncoder.copyTextureToBuffer', 'source');
+      const destinationObject = assertObject(destination, 'GPUCommandEncoder.copyTextureToBuffer', 'destination');
+      const sizeObject = assertObject(copySize, 'GPUCommandEncoder.copyTextureToBuffer', 'copySize');
+      if (sourceObject.origin !== undefined) {
+        assertObject(sourceObject.origin, 'GPUCommandEncoder.copyTextureToBuffer', 'source.origin');
+      }
+      assertIntegerInRange(destinationObject.offset ?? 0, 'GPUCommandEncoder.copyTextureToBuffer', 'destination.offset', { min: 0 });
+      assertIntegerInRange(destinationObject.bytesPerRow ?? 0, 'GPUCommandEncoder.copyTextureToBuffer', 'destination.bytesPerRow', { min: 0 });
+      assertIntegerInRange(destinationObject.rowsPerImage ?? 0, 'GPUCommandEncoder.copyTextureToBuffer', 'destination.rowsPerImage', { min: 0 });
+      assertIntegerInRange(sizeObject.width, 'GPUCommandEncoder.copyTextureToBuffer', 'copySize.width', { min: 1, max: UINT32_MAX });
+      assertIntegerInRange(sizeObject.height, 'GPUCommandEncoder.copyTextureToBuffer', 'copySize.height', { min: 1, max: UINT32_MAX });
+      if (sizeObject.depthOrArrayLayers !== undefined) {
+        assertIntegerInRange(sizeObject.depthOrArrayLayers, 'GPUCommandEncoder.copyTextureToBuffer', 'copySize.depthOrArrayLayers', { min: 1, max: UINT32_MAX });
+      }
+      backend.commandEncoderCopyTextureToBuffer(
+        this,
+        {
+          texture: assertLiveResource(sourceObject.texture, 'GPUCommandEncoder.copyTextureToBuffer', 'GPUTexture'),
+          mipLevel: sourceObject.mipLevel ?? 0,
+          origin: {
+            x: sourceObject.origin?.x ?? 0,
+            y: sourceObject.origin?.y ?? 0,
+            z: sourceObject.origin?.z ?? 0,
+          },
+          aspect: sourceObject.aspect,
+        },
+        {
+          buffer: assertLiveResource(destinationObject.buffer, 'GPUCommandEncoder.copyTextureToBuffer', 'GPUBuffer'),
+          offset: destinationObject.offset ?? 0,
+          bytesPerRow: destinationObject.bytesPerRow ?? 0,
+          rowsPerImage: destinationObject.rowsPerImage ?? 0,
+        },
+        {
+          width: sizeObject.width,
+          height: sizeObject.height,
+          depthOrArrayLayers: sizeObject.depthOrArrayLayers ?? 1,
+        },
+      );
+    }
+
+    writeTimestamp(querySet, queryIndex) {
+      this._assertOpen('GPUCommandEncoder.writeTimestamp');
+      const querySetNative = assertLiveResource(querySet, 'GPUCommandEncoder.writeTimestamp', 'GPUQuerySet');
+      assertIntegerInRange(queryIndex, 'GPUCommandEncoder.writeTimestamp', 'queryIndex', { min: 0, max: UINT32_MAX });
+      if (queryIndex >= querySet.count) {
+        failValidation('GPUCommandEncoder.writeTimestamp', `queryIndex ${queryIndex} exceeds querySet count ${querySet.count}`);
+      }
+      backend.commandEncoderWriteTimestamp(this, querySetNative, queryIndex);
+    }
+
+    resolveQuerySet(querySet, firstQuery, queryCount, destination, destinationOffset) {
+      this._assertOpen('GPUCommandEncoder.resolveQuerySet');
+      const querySetNative = assertLiveResource(querySet, 'GPUCommandEncoder.resolveQuerySet', 'GPUQuerySet');
+      assertIntegerInRange(firstQuery, 'GPUCommandEncoder.resolveQuerySet', 'firstQuery', { min: 0, max: UINT32_MAX });
+      assertIntegerInRange(queryCount, 'GPUCommandEncoder.resolveQuerySet', 'queryCount', { min: 1, max: UINT32_MAX });
+      if (firstQuery + queryCount > querySet.count) {
+        failValidation('GPUCommandEncoder.resolveQuerySet', `firstQuery ${firstQuery} + queryCount ${queryCount} exceeds querySet count ${querySet.count}`);
+      }
+      const destinationNative = assertLiveResource(destination, 'GPUCommandEncoder.resolveQuerySet', 'GPUBuffer');
+      assertIntegerInRange(destinationOffset, 'GPUCommandEncoder.resolveQuerySet', 'destinationOffset', { min: 0 });
+      backend.commandEncoderResolveQuerySet(this, querySetNative, firstQuery, queryCount, destinationNative, destinationOffset);
+    }
+
+    finish() {
+      this._assertOpen('GPUCommandEncoder.finish');
+      return backend.commandEncoderFinish(this);
+    }
+  }
+
+  classes = {
+    DoeGPUComputePassEncoder,
+    DoeGPURenderPassEncoder,
+    DoeGPUCommandEncoder,
+  };
+  return classes;
+}
+
+export {
+  createEncoderClasses,
+};