@simulatte/webgpu 0.3.1 → 0.3.2

package/src/bun-ffi.js

@@ -4,89 +4,113 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createDoeRuntime, runDawnVsDoeCompare } from "./runtime_cli.js";
 import { loadDoeBuildMetadata } from "./build_metadata.js";
-import { inferAutoBindGroupLayouts } from "./auto_bind_group_layout.js";
+import { globals } from "./webgpu_constants.js";
+import {
+  UINT32_MAX,
+  failValidation,
+  describeResourceLabel,
+  initResource,
+  assertObject,
+  assertArray,
+  assertBoolean,
+  assertNonEmptyString,
+  assertIntegerInRange,
+  assertOptionalIntegerInRange,
+  assertLiveResource,
+  destroyResource,
+  validatePositiveInteger,
+} from "./shared/resource-lifecycle.js";
+import {
+  publishLimits,
+  publishFeatures,
+} from "./shared/capabilities.js";
+import {
+  ALL_BUFFER_USAGE_BITS,
+  assertBufferDescriptor,
+  assertTextureSize,
+  assertBindGroupResource as normalizeBindGroupResource,
+  normalizeTextureDimension,
+  normalizeBindGroupLayoutEntry,
+  autoLayoutEntriesFromNativeBindings,
+} from "./shared/validation.js";
+import {
+  setupGlobalsOnTarget,
+  requestAdapterFromCreate,
+  requestDeviceFromRequestAdapter,
+  buildProviderInfo,
+  libraryFlavor,
+} from "./shared/public-surface.js";
+import {
+  shaderCheckFailure,
+  enrichNativeCompilerError,
+  compilerErrorFromMessage,
+} from "./shared/compiler-errors.js";
+import {
+  createFullSurfaceClasses,
+} from "./shared/full-surface.js";
+import {
+  createEncoderClasses,
+} from "./shared/encoder-surface.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = resolve(__dirname, "..");
 
+export { globals };
+
 const CALLBACK_MODE_ALLOW_PROCESS_EVENTS = 2;
+const WGPU_STATUS_SUCCESS = 1;
 const REQUEST_ADAPTER_STATUS_SUCCESS = 1;
 const REQUEST_DEVICE_STATUS_SUCCESS = 1;
 const MAP_ASYNC_STATUS_SUCCESS = 1;
 const STYPE_SHADER_SOURCE_WGSL = 0x00000002;
 const PROCESS_EVENTS_TIMEOUT_NS = 5_000_000_000;
+let processEventsTimeoutNs = PROCESS_EVENTS_TIMEOUT_NS;
+const SAMPLER_BINDING_TYPE = Object.freeze({
+    filtering: 2,
+    "non-filtering": 3,
+    comparison: 4,
+});
+const TEXTURE_SAMPLE_TYPE = Object.freeze({
+    float: 2,
+    "unfilterable-float": 3,
+    depth: 4,
+    sint: 5,
+    uint: 6,
+});
+const TEXTURE_VIEW_DIMENSION = Object.freeze({
+    "1d": 1,
+    "2d": 2,
+    "2d-array": 3,
+    cube: 4,
+    "cube-array": 5,
+    "3d": 6,
+});
+const STORAGE_TEXTURE_ACCESS = Object.freeze({
+    "write-only": 2,
+    "read-only": 3,
+    "read-write": 4,
+});
 
 // Struct layout constants for 64-bit platforms (LP64 / LLP64).
 const PTR_SIZE = 8;
 const SIZE_T_SIZE = 8;
-
-// WebGPU enum constants (standard values) — matches index.js.
-export const globals = {
-    GPUBufferUsage: {
-        MAP_READ:      0x0001,
-        MAP_WRITE:     0x0002,
-        COPY_SRC:      0x0004,
-        COPY_DST:      0x0008,
-        INDEX:         0x0010,
-        VERTEX:        0x0020,
-        UNIFORM:       0x0040,
-        STORAGE:       0x0080,
-        INDIRECT:      0x0100,
-        QUERY_RESOLVE: 0x0200,
-    },
-    GPUShaderStage: {
-        VERTEX:   0x1,
-        FRAGMENT: 0x2,
-        COMPUTE:  0x4,
-    },
-    GPUMapMode: {
-        READ:  0x0001,
-        WRITE: 0x0002,
-    },
-    GPUTextureUsage: {
-        COPY_SRC:          0x01,
-        COPY_DST:          0x02,
-        TEXTURE_BINDING:   0x04,
-        STORAGE_BINDING:   0x08,
-        RENDER_ATTACHMENT: 0x10,
-    },
-};
-
-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_FEATURES = Object.freeze(new Set(["shader-f16"]));
+const WGPU_BUFFER_DESCRIPTOR_SIZE = 48;
+const WGPU_SHADER_SOURCE_WGSL_SIZE = 32;
+const WGPU_SHADER_MODULE_DESCRIPTOR_SIZE = 24;
+const WGPU_COMPUTE_PIPELINE_DESCRIPTOR_SIZE = 80;
+const WGPU_RENDER_PIPELINE_DESCRIPTOR_SIZE = 168;
+const WGPU_BIND_GROUP_LAYOUT_DESCRIPTOR_SIZE = 40;
+const WGPU_BIND_GROUP_DESCRIPTOR_SIZE = 48;
+const WGPU_PIPELINE_LAYOUT_DESCRIPTOR_SIZE = 48;
+const WGPU_RENDER_PASS_DESCRIPTOR_SIZE = 64;
+const WGPU_LIMITS_SIZE = 152;
+const WGPU_RENDER_VERTEX_STATE_SIZE = 64;
+const WGPU_RENDER_COLOR_TARGET_STATE_SIZE = 32;
+const WGPU_RENDER_FRAGMENT_STATE_SIZE = 64;
+const WGPU_VERTEX_ATTRIBUTE_SIZE = 32;
+const WGPU_VERTEX_BUFFER_LAYOUT_SIZE = 40;
+const WGPU_DEPTH_STENCIL_STATE_SIZE = 72;
+const WGPU_RENDER_PASS_DEPTH_STENCIL_ATTACHMENT_SIZE = 48;
 
 // ---------------------------------------------------------------------------
 // Library resolution
@@ -98,8 +122,8 @@ function resolveDoeLibraryPath() {
     const ext = LIB_EXT[process.platform] ?? "so";
     const candidates = [
         process.env.DOE_WEBGPU_LIB,
-        resolve(PACKAGE_ROOT, "prebuilds", `${process.platform}-${process.arch}`, `libwebgpu_doe.${ext}`),
         resolve(PACKAGE_ROOT, "..", "..", "zig", "zig-out", "lib", `libwebgpu_doe.${ext}`),
+        resolve(PACKAGE_ROOT, "prebuilds", `${process.platform}-${process.arch}`, `libwebgpu_doe.${ext}`),
         resolve(process.cwd(), "zig", "zig-out", "lib", `libwebgpu_doe.${ext}`),
     ];
     for (const c of candidates) {
@@ -131,8 +155,16 @@ function openLibrary(path) {
         // Adapter/Device (flat helpers)
         doeRequestAdapterFlat:    { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u64 },
         doeRequestDeviceFlat:     { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u64 },
+        doeNativeAdapterHasFeature: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+        doeNativeAdapterGetLimits:  { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+        doeNativeDeviceHasFeature:  { args: [FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+        doeNativeDeviceGetLimits:   { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
         wgpuAdapterRelease:       { args: [FFIType.ptr], returns: FFIType.void },
+        wgpuAdapterHasFeature:    { args: [FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+        wgpuAdapterGetLimits:     { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
         wgpuDeviceRelease:        { args: [FFIType.ptr], returns: FFIType.void },
+        wgpuDeviceHasFeature:     { args: [FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+        wgpuDeviceGetLimits:      { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
         wgpuDeviceGetQueue:       { args: [FFIType.ptr], returns: FFIType.ptr },
 
         // Buffer
@@ -153,6 +185,7 @@ function openLibrary(path) {
         // Shader
         wgpuDeviceCreateShaderModule: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
         wgpuShaderModuleRelease:  { args: [FFIType.ptr], returns: FFIType.void },
+        doeNativeShaderModuleGetBindings: { args: [FFIType.ptr, FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
 
         // Compute pipeline
         wgpuDeviceCreateComputePipeline: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
@@ -172,6 +205,8 @@ function openLibrary(path) {
         wgpuCommandEncoderRelease: { args: [FFIType.ptr], returns: FFIType.void },
         wgpuCommandEncoderBeginComputePass: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
         wgpuCommandEncoderCopyBufferToBuffer: { args: [FFIType.ptr, FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.u64], returns: FFIType.void },
+        wgpuCommandEncoderCopyTextureToBuffer: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.void },
+        doeNativeCommandEncoderCopyTextureToBuffer: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u64, FFIType.u32, FFIType.u32, FFIType.u32, FFIType.u32, FFIType.u32], returns: FFIType.void },
         wgpuCommandEncoderFinish: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
         wgpuCommandBufferRelease: { args: [FFIType.ptr], returns: FFIType.void },
 
@@ -200,7 +235,11 @@ function openLibrary(path) {
         // Render pass
         wgpuCommandEncoderBeginRenderPass: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
         wgpuRenderPassEncoderSetPipeline: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.void },
+        wgpuRenderPassEncoderSetBindGroup: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.void },
+        wgpuRenderPassEncoderSetVertexBuffer: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u64, FFIType.u64], returns: FFIType.void },
+        wgpuRenderPassEncoderSetIndexBuffer: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.u64, FFIType.u64], returns: FFIType.void },
         wgpuRenderPassEncoderDraw: { args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u32, FFIType.u32], returns: FFIType.void },
+        wgpuRenderPassEncoderDrawIndexed: { args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u32, FFIType.i32, FFIType.u32], returns: FFIType.void },
         wgpuRenderPassEncoderEnd: { args: [FFIType.ptr], returns: FFIType.void },
         wgpuRenderPassEncoderRelease: { args: [FFIType.ptr], returns: FFIType.void },
     };
@@ -209,6 +248,67 @@ function openLibrary(path) {
             args: [FFIType.ptr, FFIType.u32],
             returns: FFIType.ptr,
         };
+        symbols.doeNativeCheckShaderSource = {
+            args: [FFIType.ptr, FFIType.u64],
+            returns: FFIType.u32,
+        };
+        symbols.doeNativeCopyLastErrorMessage = {
+            args: [FFIType.ptr, FFIType.u64],
+            returns: FFIType.u64,
+        };
+        symbols.doeNativeCopyLastErrorStage = {
+            args: [FFIType.ptr, FFIType.u64],
+            returns: FFIType.u64,
+        };
+        symbols.doeNativeCopyLastErrorKind = {
+            args: [FFIType.ptr, FFIType.u64],
+            returns: FFIType.u64,
+        };
+        symbols.doeNativeGetLastErrorLine = {
+            args: [],
+            returns: FFIType.u32,
+        };
+        symbols.doeNativeGetLastErrorColumn = {
+            args: [],
+            returns: FFIType.u32,
+        };
+        symbols.doeNativeDeviceCreateQuerySet = {
+            args: [FFIType.ptr, FFIType.u32, FFIType.u32],
+            returns: FFIType.ptr,
+        };
+        symbols.doeNativeCommandEncoderWriteTimestamp = {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.u32],
+            returns: FFIType.void,
+        };
+        symbols.doeNativeCommandEncoderResolveQuerySet = {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.ptr, FFIType.u64],
+            returns: FFIType.void,
+        };
+        symbols.doeNativeQuerySetDestroy = {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        };
+        symbols.doeNativeQueueFlush = {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        };
+        symbols.doeNativeComputeDispatchFlush = {
+            args: [
+                FFIType.ptr,  // queue
+                FFIType.ptr,  // pipeline
+                FFIType.ptr,  // bindGroups (ptr array)
+                FFIType.u32,  // bgCount
+                FFIType.u32,  // x
+                FFIType.u32,  // y
+                FFIType.u32,  // z
+                FFIType.ptr,  // copySrc
+                FFIType.u64,  // copySrcOff
+                FFIType.ptr,  // copyDst
+                FFIType.u64,  // copyDstOff
+                FFIType.u64,  // copySize
+            ],
+            returns: FFIType.void,
+        };
     }
     return dlopen(path, symbols);
 }
@@ -221,6 +321,194 @@ function openLibrary(path) {
 // ---------------------------------------------------------------------------
 
 const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+const LIMIT_OFFSETS = Object.freeze({
+    maxTextureDimension1D: 8,
+    maxTextureDimension2D: 12,
+    maxTextureDimension3D: 16,
+    maxTextureArrayLayers: 20,
+    maxBindGroups: 24,
+    maxBindGroupsPlusVertexBuffers: 28,
+    maxBindingsPerBindGroup: 32,
+    maxDynamicUniformBuffersPerPipelineLayout: 36,
+    maxDynamicStorageBuffersPerPipelineLayout: 40,
+    maxSampledTexturesPerShaderStage: 44,
+    maxSamplersPerShaderStage: 48,
+    maxStorageBuffersPerShaderStage: 52,
+    maxStorageTexturesPerShaderStage: 56,
+    maxUniformBuffersPerShaderStage: 60,
+    maxUniformBufferBindingSize: 64,
+    maxStorageBufferBindingSize: 72,
+    minUniformBufferOffsetAlignment: 80,
+    minStorageBufferOffsetAlignment: 84,
+    maxVertexBuffers: 88,
+    maxBufferSize: 96,
+    maxVertexAttributes: 104,
+    maxVertexBufferArrayStride: 108,
+    maxInterStageShaderVariables: 112,
+    maxColorAttachments: 116,
+    maxColorAttachmentBytesPerSample: 120,
+    maxComputeWorkgroupStorageSize: 124,
+    maxComputeInvocationsPerWorkgroup: 128,
+    maxComputeWorkgroupSizeX: 132,
+    maxComputeWorkgroupSizeY: 136,
+    maxComputeWorkgroupSizeZ: 140,
+    maxComputeWorkgroupsPerDimension: 144,
+});
+
+function copyLastErrorMessage() {
+    const fn = wgpu?.symbols?.doeNativeCopyLastErrorMessage;
+    if (typeof fn !== "function") return "";
+    const buf = new Uint8Array(4096);
+    const len = Number(fn(buf, BigInt(buf.length)));
+    if (len <= 1) return "";
+    return decoder.decode(buf.subarray(0, Math.max(0, len - 1)));
+}
+
+function decodeLimits(raw) {
+    const view = new DataView(raw);
+    return Object.freeze({
+        maxTextureDimension1D: view.getUint32(LIMIT_OFFSETS.maxTextureDimension1D, true),
+        maxTextureDimension2D: view.getUint32(LIMIT_OFFSETS.maxTextureDimension2D, true),
+        maxTextureDimension3D: view.getUint32(LIMIT_OFFSETS.maxTextureDimension3D, true),
+        maxTextureArrayLayers: view.getUint32(LIMIT_OFFSETS.maxTextureArrayLayers, true),
+        maxBindGroups: view.getUint32(LIMIT_OFFSETS.maxBindGroups, true),
+        maxBindGroupsPlusVertexBuffers: view.getUint32(LIMIT_OFFSETS.maxBindGroupsPlusVertexBuffers, true),
+        maxBindingsPerBindGroup: view.getUint32(LIMIT_OFFSETS.maxBindingsPerBindGroup, true),
+        maxDynamicUniformBuffersPerPipelineLayout: view.getUint32(LIMIT_OFFSETS.maxDynamicUniformBuffersPerPipelineLayout, true),
+        maxDynamicStorageBuffersPerPipelineLayout: view.getUint32(LIMIT_OFFSETS.maxDynamicStorageBuffersPerPipelineLayout, true),
+        maxSampledTexturesPerShaderStage: view.getUint32(LIMIT_OFFSETS.maxSampledTexturesPerShaderStage, true),
+        maxSamplersPerShaderStage: view.getUint32(LIMIT_OFFSETS.maxSamplersPerShaderStage, true),
+        maxStorageBuffersPerShaderStage: view.getUint32(LIMIT_OFFSETS.maxStorageBuffersPerShaderStage, true),
+        maxStorageTexturesPerShaderStage: view.getUint32(LIMIT_OFFSETS.maxStorageTexturesPerShaderStage, true),
+        maxUniformBuffersPerShaderStage: view.getUint32(LIMIT_OFFSETS.maxUniformBuffersPerShaderStage, true),
+        maxUniformBufferBindingSize: Number(view.getBigUint64(LIMIT_OFFSETS.maxUniformBufferBindingSize, true)),
+        maxStorageBufferBindingSize: Number(view.getBigUint64(LIMIT_OFFSETS.maxStorageBufferBindingSize, true)),
+        minUniformBufferOffsetAlignment: view.getUint32(LIMIT_OFFSETS.minUniformBufferOffsetAlignment, true),
+        minStorageBufferOffsetAlignment: view.getUint32(LIMIT_OFFSETS.minStorageBufferOffsetAlignment, true),
+        maxVertexBuffers: view.getUint32(LIMIT_OFFSETS.maxVertexBuffers, true),
+        maxBufferSize: Number(view.getBigUint64(LIMIT_OFFSETS.maxBufferSize, true)),
+        maxVertexAttributes: view.getUint32(LIMIT_OFFSETS.maxVertexAttributes, true),
+        maxVertexBufferArrayStride: view.getUint32(LIMIT_OFFSETS.maxVertexBufferArrayStride, true),
+        maxInterStageShaderVariables: view.getUint32(LIMIT_OFFSETS.maxInterStageShaderVariables, true),
+        maxColorAttachments: view.getUint32(LIMIT_OFFSETS.maxColorAttachments, true),
+        maxColorAttachmentBytesPerSample: view.getUint32(LIMIT_OFFSETS.maxColorAttachmentBytesPerSample, true),
+        maxComputeWorkgroupStorageSize: view.getUint32(LIMIT_OFFSETS.maxComputeWorkgroupStorageSize, true),
+        maxComputeInvocationsPerWorkgroup: view.getUint32(LIMIT_OFFSETS.maxComputeInvocationsPerWorkgroup, true),
+        maxComputeWorkgroupSizeX: view.getUint32(LIMIT_OFFSETS.maxComputeWorkgroupSizeX, true),
+        maxComputeWorkgroupSizeY: view.getUint32(LIMIT_OFFSETS.maxComputeWorkgroupSizeY, true),
+        maxComputeWorkgroupSizeZ: view.getUint32(LIMIT_OFFSETS.maxComputeWorkgroupSizeZ, true),
+        maxComputeWorkgroupsPerDimension: view.getUint32(LIMIT_OFFSETS.maxComputeWorkgroupsPerDimension, true),
+    });
+}
+
+function queryLimits(handle, fnName) {
+    const fn = wgpu?.symbols?.[fnName];
+    if (typeof fn !== "function" || !handle) return publishLimits(null);
+    const raw = new ArrayBuffer(WGPU_LIMITS_SIZE);
+    const status = Number(fn(handle, new Uint8Array(raw)));
+    if (status !== WGPU_STATUS_SUCCESS) return publishLimits(null);
+    return publishLimits(decodeLimits(raw));
+}
+
+function queryLimitsByPreference(handle, fnNames) {
+    for (const fnName of fnNames) {
+        const fn = wgpu?.symbols?.[fnName];
+        if (typeof fn !== "function" || !handle) continue;
+        const raw = new ArrayBuffer(WGPU_LIMITS_SIZE);
+        const status = Number(fn(handle, new Uint8Array(raw)));
+        if (status !== WGPU_STATUS_SUCCESS) continue;
+        return publishLimits(decodeLimits(raw));
+    }
+    return publishLimits(null);
+}
+
+function adapterLimits(handle) {
+    return queryLimitsByPreference(handle, ["doeNativeAdapterGetLimits", "wgpuAdapterGetLimits"]);
+}
+
+function deviceLimits(handle) {
+    return queryLimitsByPreference(handle, ["doeNativeDeviceGetLimits", "wgpuDeviceGetLimits"]);
+}
+
+function adapterFeatures(handle) {
+    const fn = wgpu?.symbols?.doeNativeAdapterHasFeature ?? wgpu?.symbols?.wgpuAdapterHasFeature;
+    return publishFeatures(
+        typeof fn === "function" && handle
+            ? (feature) => Number(fn(handle, feature)) !== 0
+            : null,
+    );
+}
+
+function deviceFeatures(handle) {
+    const fn = wgpu?.symbols?.doeNativeDeviceHasFeature ?? wgpu?.symbols?.wgpuDeviceHasFeature;
+    return publishFeatures(
+        typeof fn === "function" && handle
+            ? (feature) => Number(fn(handle, feature)) !== 0
+            : null,
+    );
+}
+
+function copyNativeErrorMeta(symbolName) {
+    const fn = wgpu?.symbols?.[symbolName];
+    if (typeof fn !== "function") return "";
+    const scratch = new Uint8Array(256);
+    const len = Number(fn(scratch, scratch.length));
+    if (!len) return "";
+    return decoder.decode(scratch.subarray(0, Math.min(len, scratch.length - 1)));
+}
+
+const fastPathStats = { dispatchFlush: 0, flushAndMap: 0 };
+
+/**
+ * Read structured error fields (stage, kind, line, column) from the native
+ * last-error ABI. Uses `doeNativeGetLastErrorLine` / `doeNativeGetLastErrorColumn`
+ * when available; falls back to string copy functions for stage/kind.
+ * Returns null when the native symbols are absent (pre-structured-error builds).
+ */
+function readLastErrorFields() {
+    const stageFn = wgpu?.symbols?.doeNativeCopyLastErrorStage;
+    const kindFn = wgpu?.symbols?.doeNativeCopyLastErrorKind;
+    if (typeof stageFn !== "function" && typeof kindFn !== "function") return null;
+    const stage = copyNativeErrorMeta("doeNativeCopyLastErrorStage");
+    const kind = copyNativeErrorMeta("doeNativeCopyLastErrorKind");
+    const lineFn = wgpu?.symbols?.doeNativeGetLastErrorLine;
+    const colFn = wgpu?.symbols?.doeNativeGetLastErrorColumn;
+    const line = typeof lineFn === "function" ? Number(lineFn()) : 0;
+    const column = typeof colFn === "function" ? Number(colFn()) : 0;
+    return {
+        stage: stage || undefined,
+        kind: kind || undefined,
+        line: line > 0 ? line : undefined,
+        column: column > 0 ? column : undefined,
+    };
+}
+
+function preflightShaderSource(code) {
+    const fn = wgpu?.symbols?.doeNativeCheckShaderSource;
+    if (typeof fn !== "function") {
+        return { ok: true, stage: "", kind: "", message: "", reasons: [] };
+    }
+    const codeBytes = encoder.encode(code);
+    const ok = Number(fn(codeBytes, codeBytes.length)) !== 0;
+    if (ok) return { ok: true, stage: "", kind: "", message: "", reasons: [] };
+    const message = copyNativeErrorMeta("doeNativeCopyLastErrorMessage");
+    const lineFn = wgpu?.symbols?.doeNativeGetLastErrorLine;
+    const colFn = wgpu?.symbols?.doeNativeGetLastErrorColumn;
+    const line = typeof lineFn === "function" ? Number(lineFn()) : 0;
+    const column = typeof colFn === "function" ? Number(colFn()) : 0;
+    const out = {
+        ok: false,
+        stage: copyNativeErrorMeta("doeNativeCopyLastErrorStage"),
+        kind: copyNativeErrorMeta("doeNativeCopyLastErrorKind"),
+        message,
+        reasons: message ? [message] : [],
+    };
+    if (line > 0) out.line = line;
+    if (column > 0) out.column = column;
+    return out;
+}
 
 function writeStringView(view, offset, strBytes) {
     if (strBytes) {
@@ -238,7 +526,7 @@ function writePtr(view, offset, ptr) {
 
 // WGPUBufferDescriptor: { nextInChain:ptr@0, label:sv@8, usage:u64@24, size:u64@32, mappedAtCreation:u32@40 } = 48
 function buildBufferDescriptor(descriptor) {
-    const buf = new ArrayBuffer(48);
+    const buf = new ArrayBuffer(WGPU_BUFFER_DESCRIPTOR_SIZE);
     const v = new DataView(buf);
     // nextInChain = null
     writePtr(v, 0, null);
@@ -258,14 +546,14 @@ function buildBufferDescriptor(descriptor) {
 function buildShaderModuleDescriptor(code) {
     const codeBytes = encoder.encode(code);
 
-    const wgslBuf = new ArrayBuffer(32);
+    const wgslBuf = new ArrayBuffer(WGPU_SHADER_SOURCE_WGSL_SIZE);
     const wgslView = new DataView(wgslBuf);
     writePtr(wgslView, 0, null);
     wgslView.setUint32(8, STYPE_SHADER_SOURCE_WGSL, true);
     writeStringView(wgslView, 16, codeBytes);
     const wgslArr = new Uint8Array(wgslBuf);
 
-    const descBuf = new ArrayBuffer(24);
+    const descBuf = new ArrayBuffer(WGPU_SHADER_MODULE_DESCRIPTOR_SIZE);
     const descView = new DataView(descBuf);
     writePtr(descView, 0, bunPtr(wgslArr));
     writeStringView(descView, 8, null);
@@ -279,7 +567,7 @@ function buildShaderModuleDescriptor(code) {
 // Total descriptor: 24 + 8 (layout) + 48 (compute) = 80
 function buildComputePipelineDescriptor(shaderModulePtr, entryPoint, layoutPtr) {
     const epBytes = encoder.encode(entryPoint);
-    const buf = new ArrayBuffer(80);
+    const buf = new ArrayBuffer(WGPU_COMPUTE_PIPELINE_DESCRIPTOR_SIZE);
     const v = new DataView(buf);
     // nextInChain
     writePtr(v, 0, null);
@@ -300,6 +588,113 @@ function buildComputePipelineDescriptor(shaderModulePtr, entryPoint, layoutPtr)
     return { desc: new Uint8Array(buf), _refs: [epBytes] };
 }
 
+function buildRenderPipelineDescriptor(descriptor) {
+    const vertexEntryBytes = encoder.encode(descriptor.vertexEntryPoint);
+    const fragmentEntryBytes = encoder.encode(descriptor.fragmentEntryPoint);
+    const vertexBuffers = descriptor.vertexBuffers ?? [];
+
+    const colorTargetBuf = new ArrayBuffer(WGPU_RENDER_COLOR_TARGET_STATE_SIZE);
+    const colorTargetView = new DataView(colorTargetBuf);
+    writePtr(colorTargetView, 0, null);
+    colorTargetView.setUint32(8, TEXTURE_FORMAT_MAP[descriptor.colorFormat] ?? 0x00000016, true);
+    writePtr(colorTargetView, 16, null);
+    colorTargetView.setBigUint64(24, 0xFn, true);
+    const colorTargetArr = new Uint8Array(colorTargetBuf);
+
+    const fragmentBuf = new ArrayBuffer(WGPU_RENDER_FRAGMENT_STATE_SIZE);
+    const fragmentView = new DataView(fragmentBuf);
+    writePtr(fragmentView, 0, null);
+    writePtr(fragmentView, 8, descriptor.fragmentModule);
+    writeStringView(fragmentView, 16, fragmentEntryBytes);
+    fragmentView.setBigUint64(32, 0n, true);
+    writePtr(fragmentView, 40, null);
+    fragmentView.setBigUint64(48, 1n, true);
+    writePtr(fragmentView, 56, bunPtr(colorTargetArr));
+    const fragmentArr = new Uint8Array(fragmentBuf);
+
+    let vertexAttributeArr = null;
+    let vertexBufferArr = null;
+    if (vertexBuffers.length > 0) {
+        let totalAttributeCount = 0;
+        for (const buffer of vertexBuffers) {
+            totalAttributeCount += (buffer.attributes ?? []).length;
+        }
+        vertexAttributeArr = new Uint8Array(totalAttributeCount * WGPU_VERTEX_ATTRIBUTE_SIZE);
+        vertexBufferArr = new Uint8Array(vertexBuffers.length * WGPU_VERTEX_BUFFER_LAYOUT_SIZE);
+        const attrView = new DataView(vertexAttributeArr.buffer);
+        const layoutView = new DataView(vertexBufferArr.buffer);
+        let attrIndex = 0;
+        for (let bufferIndex = 0; bufferIndex < vertexBuffers.length; bufferIndex += 1) {
+            const buffer = vertexBuffers[bufferIndex] ?? {};
+            const attributes = buffer.attributes ?? [];
+            const layoutOffset = bufferIndex * WGPU_VERTEX_BUFFER_LAYOUT_SIZE;
+            writePtr(layoutView, layoutOffset + 0, null);
+            layoutView.setUint32(layoutOffset + 8, VERTEX_STEP_MODE_MAP[buffer.stepMode ?? "vertex"] ?? VERTEX_STEP_MODE_MAP.vertex, true);
+            layoutView.setBigUint64(layoutOffset + 16, BigInt(buffer.arrayStride ?? 0), true);
+            layoutView.setBigUint64(layoutOffset + 24, BigInt(attributes.length), true);
+            writePtr(layoutView, layoutOffset + 32, attributes.length > 0 ? bunPtr(vertexAttributeArr) + attrIndex * WGPU_VERTEX_ATTRIBUTE_SIZE : null);
+            for (const attribute of attributes) {
+                const attrOffset = attrIndex * WGPU_VERTEX_ATTRIBUTE_SIZE;
+                writePtr(attrView, attrOffset + 0, null);
+                attrView.setUint32(attrOffset + 8, VERTEX_FORMAT_MAP[attribute.format] ?? 0, true);
+                attrView.setBigUint64(attrOffset + 16, BigInt(attribute.offset ?? 0), true);
+                attrView.setUint32(attrOffset + 24, attribute.shaderLocation ?? 0, true);
+                attrIndex += 1;
+            }
+        }
+    }
+
+    let depthStencilArr = null;
+    if (descriptor.depthStencil) {
+        const depthStencilBuf = new ArrayBuffer(WGPU_DEPTH_STENCIL_STATE_SIZE);
+        const depthStencilView = new DataView(depthStencilBuf);
+        writePtr(depthStencilView, 0, null);
+        depthStencilView.setUint32(8, TEXTURE_FORMAT_MAP[descriptor.depthStencil.format] ?? TEXTURE_FORMAT_MAP.depth32float, true);
+        depthStencilView.setUint32(12, descriptor.depthStencil.depthWriteEnabled ? 1 : 0, true);
+        depthStencilView.setUint32(16, COMPARE_FUNC_MAP[descriptor.depthStencil.depthCompare ?? "always"] ?? COMPARE_FUNC_MAP.always, true);
+        depthStencilView.setUint32(48, 0xFFFFFFFF, true);
+        depthStencilView.setUint32(52, 0xFFFFFFFF, true);
+        depthStencilArr = new Uint8Array(depthStencilBuf);
+    }
+
+    const primitive = descriptor.primitive ?? {};
+    const multisample = descriptor.multisample ?? {};
+    const buf = new ArrayBuffer(WGPU_RENDER_PIPELINE_DESCRIPTOR_SIZE);
+    const view = new DataView(buf);
+    writePtr(view, 0, null);
+    writeStringView(view, 8, null);
+    writePtr(view, 24, descriptor.layout);
+    writePtr(view, 32, null);
+    writePtr(view, 40, descriptor.vertexModule);
+    writeStringView(view, 48, vertexEntryBytes);
+    view.setBigUint64(64, 0n, true);
+    writePtr(view, 72, null);
+    view.setBigUint64(80, BigInt(vertexBuffers.length), true);
+    writePtr(view, 88, vertexBuffers.length > 0 ? bunPtr(vertexBufferArr) : null);
+    writePtr(view, 96, null);
+    view.setUint32(104, {
+        "point-list": 0x00000001,
+        "line-list": 0x00000002,
+        "line-strip": 0x00000003,
+        "triangle-list": 0x00000004,
+        "triangle-strip": 0x00000005,
+    }[primitive.topology ?? "triangle-list"] ?? 0x00000004, true);
+    view.setUint32(108, 0, true);
+    view.setUint32(112, { ccw: 0x00000001, cw: 0x00000002 }[primitive.frontFace ?? "ccw"] ?? 0x00000001, true);
+    view.setUint32(116, { none: 0x00000001, front: 0x00000002, back: 0x00000003 }[primitive.cullMode ?? "none"] ?? 0x00000001, true);
+    view.setUint32(120, primitive.unclippedDepth ? 1 : 0, true);
+    writePtr(view, 128, depthStencilArr ? bunPtr(depthStencilArr) : null);
+    writePtr(view, 136, null);
+    view.setUint32(144, multisample.count ?? 1, true);
+    view.setUint32(148, multisample.mask ?? 0xFFFF_FFFF, true);
+    view.setUint32(152, multisample.alphaToCoverageEnabled ? 1 : 0, true);
+    writePtr(view, 160, bunPtr(fragmentArr));
+    return {
+        desc: new Uint8Array(buf),
+        _refs: [vertexEntryBytes, fragmentEntryBytes, colorTargetArr, fragmentArr, vertexAttributeArr, vertexBufferArr, depthStencilArr].filter(Boolean),
+    };
+}
+
 // WGPUBindGroupLayoutEntry: { nextInChain:ptr@0, binding:u32@8, visibility:u64@12(actually u32@12 + pad), ...complex }
 // The full entry is large. We build a minimal version matching what doe_napi.c marshals.
 // For simplicity, we build the entry array matching the C struct layout.
@@ -342,11 +737,26 @@ function buildBindGroupLayoutDescriptor(entries) {
             //   buffer.minBindingSize: u64@48
             entryView.setBigUint64(off + 48, BigInt(e.buffer.minBindingSize || 0), true);
         }
-        // sampler/texture/storageTexture sub-structs (@56..120) remain zeroed
+        if (e.sampler) {
+            writePtr(entryView, off + 56, null);
+            entryView.setUint32(off + 64, SAMPLER_BINDING_TYPE[e.sampler.type] || 2, true);
+        }
+        if (e.texture) {
+            writePtr(entryView, off + 72, null);
+            entryView.setUint32(off + 80, TEXTURE_SAMPLE_TYPE[e.texture.sampleType] || 2, true);
+            entryView.setUint32(off + 84, TEXTURE_VIEW_DIMENSION[e.texture.viewDimension] || 2, true);
+            entryView.setUint32(off + 88, e.texture.multisampled ? 1 : 0, true);
+        }
+        if (e.storageTexture) {
+            writePtr(entryView, off + 96, null);
+            entryView.setUint32(off + 104, STORAGE_TEXTURE_ACCESS[e.storageTexture.access] || 2, true);
+            entryView.setUint32(off + 108, TEXTURE_FORMATS[e.storageTexture.format] || 18, true);
+            entryView.setUint32(off + 112, TEXTURE_VIEW_DIMENSION[e.storageTexture.viewDimension] || 2, true);
+        }
     }
 
     // WGPUBindGroupLayoutDescriptor: { nextInChain:ptr@0, label:sv@8, entryCount:size_t@24, entries:ptr@32 } = 40
-    const descBuf = new ArrayBuffer(40);
+    const descBuf = new ArrayBuffer(WGPU_BIND_GROUP_LAYOUT_DESCRIPTOR_SIZE);
     const descView = new DataView(descBuf);
     writePtr(descView, 0, null);
     writeStringView(descView, 8, null);
@@ -370,16 +780,16 @@ function buildBindGroupDescriptor(layoutPtr, entries) {
         const off = i * BIND_GROUP_ENTRY_SIZE;
         writePtr(entryView, off + 0, null);
         entryView.setUint32(off + 8, e.binding, true);
-        const bufferPtr = e.resource?.buffer?._native ?? e.resource?._native ?? null;
+        const bufferPtr = e.resource?.buffer ?? null;
         writePtr(entryView, off + 16, bufferPtr);
         entryView.setBigUint64(off + 24, BigInt(e.resource?.offset ?? 0), true);
         entryView.setBigUint64(off + 32, e.resource?.size !== undefined ? BigInt(e.resource.size) : WHOLE_SIZE, true);
-        writePtr(entryView, off + 40, null); // sampler
-        writePtr(entryView, off + 48, null); // textureView
+        writePtr(entryView, off + 40, e.resource?.sampler ?? null);
+        writePtr(entryView, off + 48, e.resource?.textureView ?? null);
     }
 
     // WGPUBindGroupDescriptor: { nextInChain:ptr@0, label:sv@8, layout:ptr@24, entryCount:size_t@32, entries:ptr@40 } = 48
-    const descBuf = new ArrayBuffer(48);
+    const descBuf = new ArrayBuffer(WGPU_BIND_GROUP_DESCRIPTOR_SIZE);
     const descView = new DataView(descBuf);
     writePtr(descView, 0, null);
     writeStringView(descView, 8, null);
@@ -398,7 +808,7 @@ function buildPipelineLayoutDescriptor(layouts) {
         ptrs[i] = BigInt(layouts[i]);
     }
 
-    const descBuf = new ArrayBuffer(48);
+    const descBuf = new ArrayBuffer(WGPU_PIPELINE_LAYOUT_DESCRIPTOR_SIZE);
     const descView = new DataView(descBuf);
     writePtr(descView, 0, null);
     writeStringView(descView, 8, null);
@@ -440,19 +850,104 @@ function buildPipelineLayoutDescriptor(layouts) {
 const TEXTURE_DESC_SIZE = 80;
 
 const TEXTURE_FORMAT_MAP = {
-    rgba8unorm: 18, "rgba8unorm-srgb": 19, bgra8unorm: 23, "bgra8unorm-srgb": 24,
-    r32float: 33, rg32float: 43, rgba32float: 52, depth32float: 55,
+    r8unorm: 0x01, r8snorm: 0x02, r8uint: 0x03, r8sint: 0x04,
+    r16uint: 0x07, r16sint: 0x08, r16float: 0x09,
+    rg8unorm: 0x0A, rg8snorm: 0x0B, rg8uint: 0x0C, rg8sint: 0x0D,
+    r32float: 0x0E, r32uint: 0x0F, r32sint: 0x10,
+    rg16uint: 0x13, rg16sint: 0x14, rg16float: 0x15,
+    rgba8unorm: 0x16, "rgba8unorm-srgb": 0x17, rgba8snorm: 0x18, rgba8uint: 0x19, rgba8sint: 0x1A,
+    bgra8unorm: 0x1B, "bgra8unorm-srgb": 0x1C,
+    rgb10a2uint: 0x1D, rgb10a2unorm: 0x1E, rg11b10ufloat: 0x1F, rgb9e5ufloat: 0x20,
+    rg32float: 0x21, rg32uint: 0x22, rg32sint: 0x23,
+    rgba16uint: 0x24, rgba16sint: 0x25, rgba16float: 0x26,
+    rgba32float: 0x27, rgba32uint: 0x28, rgba32sint: 0x29,
+    stencil8: 0x2C, depth16unorm: 0x2D,
+    depth24plus: 0x2E, "depth24plus-stencil8": 0x2F,
+    depth32float: 0x30, "depth32float-stencil8": 0x31,
+    // BC compressed formats (texture-compression-bc feature)
+    "bc1-rgba-unorm": 0x32, "bc1-rgba-unorm-srgb": 0x33,
+    "bc2-rgba-unorm": 0x34, "bc2-rgba-unorm-srgb": 0x35,
+    "bc3-rgba-unorm": 0x36, "bc3-rgba-unorm-srgb": 0x37,
+    "bc4-r-unorm": 0x38, "bc4-r-snorm": 0x39,
+    "bc5-rg-unorm": 0x3A, "bc5-rg-snorm": 0x3B,
+    "bc6h-rgb-ufloat": 0x3C, "bc6h-rgb-float": 0x3D,
+    "bc7-rgba-unorm": 0x3E, "bc7-rgba-unorm-srgb": 0x3F,
+    // ETC2/EAC compressed formats (texture-compression-etc2 feature)
+    "etc2-rgb8unorm": 0x40, "etc2-rgb8unorm-srgb": 0x41,
+    "etc2-rgb8a1unorm": 0x42, "etc2-rgb8a1unorm-srgb": 0x43,
+    "etc2-rgba8unorm": 0x44, "etc2-rgba8unorm-srgb": 0x45,
+    "eac-r11unorm": 0x46, "eac-r11snorm": 0x47,
+    "eac-rg11unorm": 0x48, "eac-rg11snorm": 0x49,
+    // ASTC compressed formats (texture-compression-astc feature)
+    "astc-4x4-unorm": 0x4A, "astc-4x4-unorm-srgb": 0x4B,
+    "astc-5x4-unorm": 0x4C, "astc-5x4-unorm-srgb": 0x4D,
+    "astc-5x5-unorm": 0x4E, "astc-5x5-unorm-srgb": 0x4F,
+    "astc-6x5-unorm": 0x50, "astc-6x5-unorm-srgb": 0x51,
+    "astc-6x6-unorm": 0x52, "astc-6x6-unorm-srgb": 0x53,
+    "astc-8x5-unorm": 0x54, "astc-8x5-unorm-srgb": 0x55,
+    "astc-8x6-unorm": 0x56, "astc-8x6-unorm-srgb": 0x57,
+    "astc-8x8-unorm": 0x58, "astc-8x8-unorm-srgb": 0x59,
+    "astc-10x5-unorm": 0x5A, "astc-10x5-unorm-srgb": 0x5B,
+    "astc-10x6-unorm": 0x5C, "astc-10x6-unorm-srgb": 0x5D,
+    "astc-10x8-unorm": 0x5E, "astc-10x8-unorm-srgb": 0x5F,
+    "astc-10x10-unorm": 0x60, "astc-10x10-unorm-srgb": 0x61,
+    "astc-12x10-unorm": 0x62, "astc-12x10-unorm-srgb": 0x63,
+    "astc-12x12-unorm": 0x64, "astc-12x12-unorm-srgb": 0x65,
 };
 
+// Alias used by bind group layout storage texture format lookup
+const TEXTURE_FORMATS = TEXTURE_FORMAT_MAP;
+
+const VERTEX_FORMAT_MAP = {
+    float32: 0x00000019,
+    float32x2: 0x0000001A,
+    float32x3: 0x0000001B,
+    float32x4: 0x0000001C,
+    uint32: 0x00000021,
+    uint32x2: 0x00000022,
+    uint32x3: 0x00000023,
+    uint32x4: 0x00000024,
+    sint32: 0x00000025,
+    sint32x2: 0x00000026,
+    sint32x3: 0x00000027,
+    sint32x4: 0x00000028,
+};
+
+const VERTEX_STEP_MODE_MAP = {
+    vertex: 0x00000001,
+    instance: 0x00000002,
+};
+
+const COMPARE_FUNC_MAP = {
+    never: 0x00000001,
+    less: 0x00000002,
+    equal: 0x00000003,
+    "less-equal": 0x00000004,
+    greater: 0x00000005,
+    "not-equal": 0x00000006,
+    "greater-equal": 0x00000007,
+    always: 0x00000008,
+};
+
+const INDEX_FORMAT_MAP = {
+    uint16: 0x00000001,
+    uint32: 0x00000002,
+};
+
+const TEXTURE_DIMENSION_MAP = Object.freeze({
+    "1d": 1,
+    "2d": 2,
+    "3d": 3,
+});
+
 function buildTextureDescriptor(descriptor) {
     const buf = new ArrayBuffer(TEXTURE_DESC_SIZE);
     const v = new DataView(buf);
     writePtr(v, 0, null);
     writeStringView(v, 8, null);
     v.setBigUint64(24, BigInt(descriptor.usage || 0), true);
-    v.setUint32(32, 1, true); // dimension = 2D (WGPUTextureDimension_2D = 1... actually 0x00000002)
-    // WGPUTextureDimension: 1D=1, 2D=2, 3D=3 in standard. Let's use 2.
-    v.setUint32(32, 2, true);
+    const dimension = descriptor.dimension ?? "2d";
+    v.setUint32(32, typeof dimension === "number" ? dimension : (TEXTURE_DIMENSION_MAP[dimension] ?? 2), true);
     const w = descriptor.size?.[0] ?? descriptor.size?.width ?? descriptor.size ?? 1;
     const h = descriptor.size?.[1] ?? descriptor.size?.height ?? 1;
     const d = descriptor.size?.[2] ?? descriptor.size?.depthOrArrayLayers ?? 1;
@@ -460,7 +955,7 @@ function buildTextureDescriptor(descriptor) {
     v.setUint32(40, h, true);
     v.setUint32(44, d, true);
     const fmt = descriptor.format || "rgba8unorm";
-    v.setUint32(48, TEXTURE_FORMAT_MAP[fmt] ?? 18, true);
+    v.setUint32(48, TEXTURE_FORMAT_MAP[fmt] ?? 0x16, true);
     v.setUint32(52, descriptor.mipLevelCount || 1, true);
     v.setUint32(56, 1, true); // sampleCount
     v.setBigUint64(64, 0n, true); // viewFormatCount
@@ -496,6 +991,9 @@ function buildSamplerDescriptor(descriptor) {
 // { nextInChain:ptr@0, view:ptr@8, depthSlice:u32@16, pad@20, resolveTarget:ptr@24,
 //   loadOp:u32@32, storeOp:u32@36, clearValue:{r:f64@40, g:f64@48, b:f64@56, a:f64@64} } = 72
 const RENDER_PASS_COLOR_ATTACHMENT_SIZE = 72;
+const TEXEL_COPY_TEXTURE_INFO_SIZE = 32;
+const TEXEL_COPY_BUFFER_INFO_SIZE = 24;
+const EXTENT3D_SIZE = 12;
 
 // WGPURenderPassDescriptor:
 // { nextInChain:ptr@0, label:sv@8, colorAttachmentCount:size_t@24, colorAttachments:ptr@32,
@@ -521,17 +1019,64 @@ function buildRenderPassDescriptor(descriptor) {
         attView.setFloat64(off + 64, cv.a ?? 1, true);
     }
 
-    const descBuf = new ArrayBuffer(64);
+    let depthStencilAttachmentArr = null;
+    if (descriptor.depthStencilAttachment?.view) {
+        const depthBuf = new ArrayBuffer(WGPU_RENDER_PASS_DEPTH_STENCIL_ATTACHMENT_SIZE);
+        const depthView = new DataView(depthBuf);
+        writePtr(depthView, 0, descriptor.depthStencilAttachment.view._native);
+        depthView.setUint32(8, 1, true); // clear
+        depthView.setUint32(12, 1, true); // store
+        depthView.setFloat32(16, descriptor.depthStencilAttachment.depthClearValue ?? 1.0, true);
+        depthView.setUint32(20, descriptor.depthStencilAttachment.depthReadOnly ? 1 : 0, true);
+        depthView.setUint32(24, 1, true); // clear
+        depthView.setUint32(28, 1, true); // store
+        depthView.setUint32(32, descriptor.depthStencilAttachment.stencilClearValue ?? 0, true);
+        depthView.setUint32(36, descriptor.depthStencilAttachment.stencilReadOnly ? 1 : 0, true);
+        depthStencilAttachmentArr = new Uint8Array(depthBuf);
+    }
+
+    const descBuf = new ArrayBuffer(WGPU_RENDER_PASS_DESCRIPTOR_SIZE);
     const descView = new DataView(descBuf);
     writePtr(descView, 0, null);
     writeStringView(descView, 8, null);
     descView.setBigUint64(24, BigInt(colorAttachments.length), true);
     writePtr(descView, 32, colorAttachments.length > 0 ? bunPtr(attBuf) : null);
-    writePtr(descView, 40, null); // depthStencilAttachment
+    writePtr(descView, 40, depthStencilAttachmentArr ? bunPtr(depthStencilAttachmentArr) : null);
     writePtr(descView, 48, null); // occlusionQuerySet
     writePtr(descView, 56, null); // timestampWrites
 
-    return { desc: new Uint8Array(descBuf), _refs: [attBuf] };
+    return { desc: new Uint8Array(descBuf), _refs: [attBuf, depthStencilAttachmentArr].filter(Boolean) };
+}
+
+function buildTexelCopyTextureInfo(source) {
+    const buf = new ArrayBuffer(TEXEL_COPY_TEXTURE_INFO_SIZE);
+    const view = new DataView(buf);
+    writePtr(view, 0, source.texture);
+    view.setUint32(8, source.mipLevel ?? 0, true);
+    view.setUint32(12, source.origin?.x ?? 0, true);
+    view.setUint32(16, source.origin?.y ?? 0, true);
+    view.setUint32(20, source.origin?.z ?? 0, true);
+    view.setUint32(24, source.aspect ?? 1, true);
+    return { desc: new Uint8Array(buf), srcRefs: null };
+}
+
+function buildTexelCopyBufferInfo(destination) {
+    const buf = new ArrayBuffer(TEXEL_COPY_BUFFER_INFO_SIZE);
+    const view = new DataView(buf);
+    view.setBigUint64(0, BigInt(destination.offset ?? 0), true);
+    view.setUint32(8, destination.bytesPerRow ?? 0, true);
+    view.setUint32(12, destination.rowsPerImage ?? 0, true);
+    writePtr(view, 16, destination.buffer);
+    return { desc: new Uint8Array(buf), dstRefs: null };
+}
+
+function buildExtent3D(size) {
+    const buf = new ArrayBuffer(EXTENT3D_SIZE);
+    const view = new DataView(buf);
+    view.setUint32(0, size.width, true);
+    view.setUint32(4, size.height, true);
+    view.setUint32(8, size.depthOrArrayLayers ?? 1, true);
+    return new Uint8Array(buf);
 }
 
 // ---------------------------------------------------------------------------
@@ -542,7 +1087,7 @@ function buildRenderPassDescriptor(descriptor) {
 // not supported on all backends (e.g. Vulkan/Dawn).
 // ---------------------------------------------------------------------------
 
-function processEventsUntilDone(instancePtr, isDone, timeoutNs = PROCESS_EVENTS_TIMEOUT_NS) {
+function processEventsUntilDone(instancePtr, isDone, timeoutNs = processEventsTimeoutNs) {
     const start = Number(process.hrtime.bigint());
     while (!isDone()) {
         wgpu.symbols.wgpuInstanceProcessEvents(instancePtr);
@@ -552,6 +1097,46 @@ function processEventsUntilDone(instancePtr, isDone, timeoutNs = PROCESS_EVENTS_
     }
 }
 
+function shaderModuleBindings(shaderModule) {
+    const fn = wgpu?.symbols?.doeNativeShaderModuleGetBindings;
+    if (typeof fn !== "function" || !shaderModule?._native) return null;
+    const count = Number(fn(shaderModule._native, null, 0n));
+    if (count <= 0) return [];
+    const raw = new ArrayBuffer(count * 20);
+    fn(shaderModule._native, new Uint8Array(raw), BigInt(count));
+    const view = new DataView(raw);
+    const bindings = [];
+    for (let index = 0; index < count; index += 1) {
+        const offset = index * 20;
+        const group = view.getUint32(offset + 0, true);
+        const binding = view.getUint32(offset + 4, true);
+        const kind = view.getUint32(offset + 8, true);
+        const addrSpace = view.getUint32(offset + 12, true);
+        const access = view.getUint32(offset + 16, true);
+        bindings.push({
+            group,
+            binding,
+            type: ["buffer", "sampler", "texture", "storage_texture"][kind] ?? "unknown",
+            space: ["function", "private", "workgroup", "uniform", "storage", "handle"][addrSpace] ?? "unknown",
+            access: ["read", "write", "read_write"][access] ?? "unknown",
+        });
+    }
+    return bindings;
+}
+
+function requireAutoLayoutEntriesFromNative(shaderModule, visibility, path) {
+    const bindings = shaderModuleBindings(shaderModule);
+    if (!Array.isArray(bindings)) {
+        throw new Error(`${path}: layout: "auto" requires native shader binding metadata on this package surface`);
+    }
+    return autoLayoutEntriesFromNativeBindings(bindings, visibility);
+}
+
+function nativeFailureMessage(prefix) {
+    const detail = copyLastErrorMessage();
+    return detail ? `${prefix}: ${detail}` : prefix;
+}
+
 function requestAdapterSync(instancePtr) {
     let resolvedAdapter = null;
     let resolvedStatus = null;
@@ -570,7 +1155,7 @@ function requestAdapterSync(instancePtr) {
         if (futureId === 0 || futureId === 0n) throw new Error("[fawn-webgpu] requestAdapter future unavailable");
         processEventsUntilDone(instancePtr, () => done);
         if (resolvedStatus !== REQUEST_ADAPTER_STATUS_SUCCESS || !resolvedAdapter) {
-            throw new Error(`[fawn-webgpu] requestAdapter failed (status=${resolvedStatus})`);
+            throw new Error(nativeFailureMessage(`[fawn-webgpu] requestAdapter failed (status=${resolvedStatus})`));
         }
         return resolvedAdapter;
     } finally {
@@ -596,7 +1181,7 @@ function requestDeviceSync(instancePtr, adapterPtr) {
         if (futureId === 0 || futureId === 0n) throw new Error("[fawn-webgpu] requestDevice future unavailable");
         processEventsUntilDone(instancePtr, () => done);
         if (resolvedStatus !== REQUEST_DEVICE_STATUS_SUCCESS || !resolvedDevice) {
-            throw new Error(`[fawn-webgpu] requestDevice failed (status=${resolvedStatus})`);
+            throw new Error(nativeFailureMessage(`[fawn-webgpu] requestDevice failed (status=${resolvedStatus})`));
         }
         return resolvedDevice;
     } finally {
@@ -609,7 +1194,7 @@ function bufferMapSync(instancePtr, bufferPtr, mode, offset, size) {
         const status = wgpu.symbols.doeBufferMapSyncFlat(
             instancePtr, bufferPtr, BigInt(mode), BigInt(offset), BigInt(size));
         if (status !== MAP_ASYNC_STATUS_SUCCESS) {
-            throw new Error(`[fawn-webgpu] bufferMapAsync failed (status=${status})`);
+            throw new Error(nativeFailureMessage(`[fawn-webgpu] bufferMapAsync failed (status=${status})`));
         }
         return;
     }
@@ -626,7 +1211,7 @@ function bufferMapSync(instancePtr, bufferPtr, mode, offset, size) {
         if (futureId === 0 || futureId === 0n) throw new Error("[fawn-webgpu] bufferMapAsync future unavailable");
         processEventsUntilDone(instancePtr, () => done);
         if (mapStatus !== MAP_ASYNC_STATUS_SUCCESS) {
-            throw new Error(`[fawn-webgpu] bufferMapAsync failed (status=${mapStatus})`);
+            throw new Error(nativeFailureMessage(`[fawn-webgpu] bufferMapAsync failed (status=${mapStatus})`));
         }
     } finally {
         cb.close();
@@ -652,11 +1237,17 @@ function waitForSubmittedWorkDoneSync(instancePtr, queuePtr) {
             null,
         );
         if (futureId === 0 || futureId === 0n) {
-            throw new Error("[fawn-webgpu] queue work-done future unavailable");
+            const error = new Error("[fawn-webgpu] queue work-done future unavailable");
+            error.code = "DOE_QUEUE_UNAVAILABLE";
+            throw error;
         }
-        processEventsUntilDone(instancePtr, () => done);
+        processEventsUntilDone(instancePtr, () => done, processEventsTimeoutNs);
         if (queueStatus !== REQUEST_DEVICE_STATUS_SUCCESS) {
-            throw new Error(`[fawn-webgpu] queue work-done failed (status=${queueStatus})`);
+            const error = new Error(nativeFailureMessage(`[fawn-webgpu] queue work-done failed (status=${queueStatus})`));
+            if (queueStatus === 0) {
+                error.code = "DOE_QUEUE_UNAVAILABLE";
+            }
+            throw error;
         }
     } finally {
         cb.close();
@@ -667,32 +1258,250 @@ function waitForSubmittedWorkDoneSync(instancePtr, queuePtr) {
 // WebGPU wrapper classes — matches index.js surface exactly
 // ---------------------------------------------------------------------------
 
-class DoeGPUBuffer {
-    constructor(native, instance, size, usage, queue) {
-        this._native = native;
-        this._instance = instance;
-        this._queue = queue;
-        this.size = size;
-        this.usage = usage;
+function ensureBunCommandEncoderNative(encoder) {
+    encoder._assertOpen("GPUCommandEncoder");
+    if (encoder._native) return;
+    encoder._native = wgpu.symbols.wgpuDeviceCreateCommandEncoder(
+        assertLiveResource(encoder._device, "GPUCommandEncoder", "GPUDevice"), null);
+    for (const cmd of encoder._commands) {
+        if (cmd.t === 0) {
+            const pass = wgpu.symbols.wgpuCommandEncoderBeginComputePass(encoder._native, null);
+            wgpu.symbols.wgpuComputePassEncoderSetPipeline(pass, cmd.p);
+            for (let i = 0; i < cmd.bg.length; i += 1) {
+                if (cmd.bg[i]) {
+                    wgpu.symbols.wgpuComputePassEncoderSetBindGroup(pass, i, cmd.bg[i], BigInt(0), null);
+                }
+            }
+            wgpu.symbols.wgpuComputePassEncoderDispatchWorkgroups(pass, cmd.x, cmd.y, cmd.z);
+            wgpu.symbols.wgpuComputePassEncoderEnd(pass);
+            wgpu.symbols.wgpuComputePassEncoderRelease(pass);
+        } else if (cmd.t === 1) {
+            wgpu.symbols.wgpuCommandEncoderCopyBufferToBuffer(
+                encoder._native, cmd.s, BigInt(cmd.so), cmd.d, BigInt(cmd.do), BigInt(cmd.sz));
+        }
     }
+    encoder._commands = [];
+}
 
-    async mapAsync(mode, offset = 0, size = this.size) {
-        if (this._queue?.hasPendingSubmissions()) {
-            waitForSubmittedWorkDoneSync(this._instance, this._queue._native);
-            this._queue.markSubmittedWorkDone();
-        }
-        bufferMapSync(this._instance, this._native, mode, offset, size);
-        this._mapMode = mode;
+function readIndirectDispatchCounts(bufferNative, offset) {
+    const dataPtr = wgpu.symbols.wgpuBufferGetConstMappedRange(bufferNative, BigInt(offset), BigInt(12));
+    if (!dataPtr) {
+        throw new Error("[fawn-webgpu] indirect dispatch buffer is not CPU-readable");
     }
+    const countsBytes = new Uint8Array(toArrayBuffer(dataPtr, 0, 12)).slice(0);
+    const counts = new DataView(countsBytes.buffer, countsBytes.byteOffset, countsBytes.byteLength);
+    return {
+        x: counts.getUint32(0, true),
+        y: counts.getUint32(4, true),
+        z: counts.getUint32(8, true),
+    };
+}
+
+const bunEncoderBackend = {
+    computePassInit(pass) {
+        pass._pipeline = null;
+        pass._bindGroups = [];
+        pass._ended = false;
+    },
+    computePassAssertOpen(pass, path) {
+        if (pass._ended) failValidation(path, "compute pass is already ended");
+        if (pass._encoder._finished) failValidation(path, "command encoder is already finished");
+    },
+    computePassSetPipeline(pass, pipelineNative) {
+        pass._pipeline = pipelineNative;
+    },
+    computePassSetBindGroup(pass, index, bindGroupNative) {
+        pass._bindGroups[index] = bindGroupNative;
+    },
+    computePassDispatchWorkgroups(pass, x, y, z) {
+        if (pass._pipeline == null) {
+            failValidation("GPUComputePassEncoder.dispatchWorkgroups", "setPipeline() must be called before dispatch");
+        }
+        pass._encoder._commands.push({ t: 0, p: pass._pipeline, bg: [...pass._bindGroups], x, y, z });
+    },
+    computePassDispatchWorkgroupsIndirect(pass, indirectBufferNative, indirectOffset) {
+        if (pass._pipeline == null) {
+            failValidation("GPUComputePassEncoder.dispatchWorkgroupsIndirect", "setPipeline() must be called before dispatch");
+        }
+        const counts = readIndirectDispatchCounts(indirectBufferNative, indirectOffset);
+        pass._encoder._commands.push({ t: 0, p: pass._pipeline, bg: [...pass._bindGroups], x: counts.x, y: counts.y, z: counts.z });
+    },
+    computePassEnd(pass) {
+        pass._ended = true;
+    },
+    renderPassInit(pass, native) {
+        pass._native = native;
+        pass._ended = false;
+    },
+    renderPassAssertOpen(pass, path) {
+        if (pass._ended) failValidation(path, "render pass is already ended");
+        if (pass._encoder._finished) failValidation(path, "command encoder is already finished");
+    },
+    renderPassSetPipeline(pass, pipelineNative) {
+        wgpu.symbols.wgpuRenderPassEncoderSetPipeline(
+            assertLiveResource(pass, "GPURenderPassEncoder.setPipeline", "GPURenderPassEncoder"),
+            pipelineNative,
+        );
+    },
+    renderPassSetBindGroup(pass, index, bindGroupNative) {
+        wgpu.symbols.wgpuRenderPassEncoderSetBindGroup(
+            assertLiveResource(pass, "GPURenderPassEncoder.setBindGroup", "GPURenderPassEncoder"),
+            index,
+            bindGroupNative,
+            BigInt(0),
+            null,
+        );
+    },
+    renderPassSetVertexBuffer(pass, slot, bufferNative, offset, size) {
+        wgpu.symbols.wgpuRenderPassEncoderSetVertexBuffer(
+            assertLiveResource(pass, "GPURenderPassEncoder.setVertexBuffer", "GPURenderPassEncoder"),
+            slot,
+            bufferNative,
+            BigInt(offset),
+            BigInt(size ?? 0),
+        );
+    },
+    renderPassSetIndexBuffer(pass, bufferNative, format, offset, size) {
+        wgpu.symbols.wgpuRenderPassEncoderSetIndexBuffer(
+            assertLiveResource(pass, "GPURenderPassEncoder.setIndexBuffer", "GPURenderPassEncoder"),
+            bufferNative,
+            INDEX_FORMAT_MAP[format] ?? INDEX_FORMAT_MAP.uint16,
+            BigInt(offset),
+            BigInt(size ?? 0),
+        );
+    },
+    renderPassDraw(pass, vertexCount, instanceCount, firstVertex, firstInstance) {
+        wgpu.symbols.wgpuRenderPassEncoderDraw(pass._native, vertexCount, instanceCount, firstVertex, firstInstance);
+    },
+    renderPassDrawIndexed(pass, indexCount, instanceCount, firstIndex, baseVertex, firstInstance) {
+        wgpu.symbols.wgpuRenderPassEncoderDrawIndexed(
+            assertLiveResource(pass, "GPURenderPassEncoder.drawIndexed", "GPURenderPassEncoder"),
+            indexCount,
+            instanceCount,
+            firstIndex,
+            baseVertex,
+            firstInstance,
+        );
+    },
+    renderPassEnd(pass) {
+        wgpu.symbols.wgpuRenderPassEncoderEnd(assertLiveResource(pass, "GPURenderPassEncoder.end", "GPURenderPassEncoder"));
+        pass._ended = true;
+    },
+    commandEncoderInit(encoder) {
+        encoder._commands = [];
+        encoder._native = null;
+        encoder._finished = false;
+    },
+    commandEncoderAssertOpen(encoder, path) {
+        if (encoder._finished) failValidation(path, "command encoder is already finished");
+    },
+    commandEncoderBeginComputePass(encoder, _descriptor, classes) {
+        return new classes.DoeGPUComputePassEncoder(null, encoder);
+    },
+    commandEncoderBeginRenderPass(encoder, descriptor, classes) {
+        ensureBunCommandEncoderNative(encoder);
+        const { desc, _refs } = buildRenderPassDescriptor(descriptor);
+        const pass = wgpu.symbols.wgpuCommandEncoderBeginRenderPass(encoder._native, desc);
+        void _refs;
+        return new classes.DoeGPURenderPassEncoder(pass, encoder);
+    },
+    commandEncoderCopyBufferToBuffer(encoder, srcNative, srcOffset, dstNative, dstOffset, size) {
+        if (encoder._native) {
+            wgpu.symbols.wgpuCommandEncoderCopyBufferToBuffer(
+                encoder._native, srcNative, BigInt(srcOffset), dstNative, BigInt(dstOffset), BigInt(size));
+            return;
+        }
+        encoder._commands.push({ t: 1, s: srcNative, so: srcOffset, d: dstNative, do: dstOffset, sz: size });
+    },
+    commandEncoderWriteTimestamp(encoder, querySetNative, queryIndex) {
+        ensureBunCommandEncoderNative(encoder);
+        if (typeof wgpu.symbols.doeNativeCommandEncoderWriteTimestamp === "function") {
+            wgpu.symbols.doeNativeCommandEncoderWriteTimestamp(encoder._native, querySetNative, queryIndex);
+        }
+    },
+    commandEncoderResolveQuerySet(encoder, querySetNative, firstQuery, queryCount, destinationNative, destinationOffset) {
+        ensureBunCommandEncoderNative(encoder);
+        if (typeof wgpu.symbols.doeNativeCommandEncoderResolveQuerySet === "function") {
+            wgpu.symbols.doeNativeCommandEncoderResolveQuerySet(
+                encoder._native, querySetNative, firstQuery, queryCount, destinationNative, BigInt(destinationOffset));
+        }
+    },
+    commandEncoderCopyTextureToBuffer(encoder, source, destination, copySize) {
+        ensureBunCommandEncoderNative(encoder);
+        if (typeof wgpu.symbols.doeNativeCommandEncoderCopyTextureToBuffer === "function") {
+            wgpu.symbols.doeNativeCommandEncoderCopyTextureToBuffer(
+                encoder._native,
+                source.texture,
+                source.mipLevel ?? 0,
+                destination.buffer,
+                BigInt(destination.offset ?? 0),
+                destination.bytesPerRow ?? 0,
+                destination.rowsPerImage ?? 0,
+                copySize.width,
+                copySize.height,
+                copySize.depthOrArrayLayers ?? 1,
+            );
+            return;
+        }
+        const { desc: srcDesc } = buildTexelCopyTextureInfo({
+            ...source,
+            texture: source.texture,
+        });
+        const { desc: dstDesc } = buildTexelCopyBufferInfo({
+            ...destination,
+            buffer: destination.buffer,
+        });
+        const extent = buildExtent3D(copySize);
+        wgpu.symbols.wgpuCommandEncoderCopyTextureToBuffer(encoder._native, srcDesc, dstDesc, extent);
+    },
+    commandEncoderFinish(encoder) {
+        encoder._finished = true;
+        if (encoder._native) {
+            const cmd = wgpu.symbols.wgpuCommandEncoderFinish(encoder._native, null);
+            encoder._native = null;
+            return { _native: cmd, _batched: false };
+        }
+        return { _commands: encoder._commands, _batched: true };
+    },
+};
+
+const {
+    DoeGPUComputePassEncoder,
+    DoeGPUCommandEncoder,
+    DoeGPURenderPassEncoder,
+} = createEncoderClasses(bunEncoderBackend);
 
-    getMappedRange(offset = 0, size = this.size) {
-        const isWrite = (this._mapMode & 0x0002) !== 0;
+const fullSurfaceBackend = {
+    initBufferState(buffer) {
+        buffer._mapMode = 0;
+        buffer._mappedWriteRanges = [];
+    },
+    bufferMarkMappedAtCreation(buffer) {
+        buffer._mapMode = 0x0002;
+        buffer._mappedWriteRanges = [];
+    },
+    bufferMapAsync(wrapper, native, mode, offset, size) {
+        if (wrapper._queue?.hasPendingSubmissions()) {
+            const queueNative = assertLiveResource(wrapper._queue, "GPUBuffer.mapAsync", "GPUQueue");
+            if (typeof wgpu.symbols.doeNativeQueueFlush === "function") {
+                wgpu.symbols.doeNativeQueueFlush(queueNative);
+                fastPathStats.flushAndMap += 1;
+            } else {
+                waitForSubmittedWorkDoneSync(wrapper._instance, queueNative);
+            }
+            wrapper._queue.markSubmittedWorkDone();
+        }
+        bufferMapSync(wrapper._instance, native, mode, offset, size);
+        wrapper._mapMode = mode;
+    },
+    bufferGetMappedRange(wrapper, native, offset, size) {
+        const isWrite = (wrapper._mapMode & 0x0002) !== 0;
         if (isWrite) {
-            const dataPtr = wgpu.symbols.wgpuBufferGetMappedRange(this._native, BigInt(offset), BigInt(size));
+            const dataPtr = wgpu.symbols.wgpuBufferGetMappedRange(native, BigInt(offset), BigInt(size));
             if (!dataPtr) throw new Error("[fawn-webgpu] getMappedRange (write) returned NULL");
             return toArrayBuffer(dataPtr, 0, size);
         }
-        const dataPtr = wgpu.symbols.wgpuBufferGetConstMappedRange(this._native, BigInt(offset), BigInt(size));
+        const dataPtr = wgpu.symbols.wgpuBufferGetConstMappedRange(native, BigInt(offset), BigInt(size));
         if (!dataPtr) throw new Error("[fawn-webgpu] getMappedRange returned NULL");
         if (DOE_LIBRARY_FLAVOR === "doe-dropin") {
             return toArrayBuffer(dataPtr, 0, size);
@@ -701,337 +1510,309 @@ class DoeGPUBuffer {
         const copy = new ArrayBuffer(size);
         new Uint8Array(copy).set(new Uint8Array(nativeView));
         return copy;
-    }
-
-    unmap() {
-        wgpu.symbols.wgpuBufferUnmap(this._native);
-        this._mapMode = 0;
-    }
-
-    destroy() {
-        wgpu.symbols.wgpuBufferRelease(this._native);
-        this._native = null;
-    }
-}
-
-class DoeGPUComputePassEncoder {
-    constructor(native) { this._native = native; }
-
-    setPipeline(pipeline) {
-        wgpu.symbols.wgpuComputePassEncoderSetPipeline(this._native, pipeline._native);
-    }
-
-    setBindGroup(index, bindGroup) {
-        wgpu.symbols.wgpuComputePassEncoderSetBindGroup(this._native, index, bindGroup._native, BigInt(0), null);
-    }
-
-    dispatchWorkgroups(x, y = 1, z = 1) {
-        wgpu.symbols.wgpuComputePassEncoderDispatchWorkgroups(this._native, x, y, z);
-    }
-
-    dispatchWorkgroupsIndirect(indirectBuffer, indirectOffset = 0) {
-        wgpu.symbols.wgpuComputePassEncoderDispatchWorkgroupsIndirect(this._native, indirectBuffer._native, BigInt(indirectOffset));
-    }
-
-    end() {
-        wgpu.symbols.wgpuComputePassEncoderEnd(this._native);
-    }
-}
-
-class DoeGPUCommandEncoder {
-    constructor(native) { this._native = native; }
-
-    beginComputePass(_descriptor) {
-        const pass = wgpu.symbols.wgpuCommandEncoderBeginComputePass(this._native, null);
-        return new DoeGPUComputePassEncoder(pass);
-    }
-
-    beginRenderPass(descriptor) {
-        const { desc, _refs } = buildRenderPassDescriptor(descriptor);
-        const pass = wgpu.symbols.wgpuCommandEncoderBeginRenderPass(this._native, desc);
-        void _refs;
-        return new DoeGPURenderPassEncoder(pass);
-    }
-
-    copyBufferToBuffer(src, srcOffset, dst, dstOffset, size) {
-        wgpu.symbols.wgpuCommandEncoderCopyBufferToBuffer(
-            this._native, src._native, BigInt(srcOffset), dst._native, BigInt(dstOffset), BigInt(size));
-    }
-
-    finish() {
-        const cmd = wgpu.symbols.wgpuCommandEncoderFinish(this._native, null);
-        return { _native: cmd };
-    }
-}
-
-class DoeGPUQueue {
-    constructor(native, instance) {
-        this._native = native;
-        this._instance = instance;
-        this._pendingSubmissions = 0;
-    }
-
-    hasPendingSubmissions() {
-        return this._pendingSubmissions > 0;
-    }
-
-    markSubmittedWorkDone() {
-        this._pendingSubmissions = 0;
-    }
-
-    submit(commandBuffers) {
-        const ptrs = new BigUint64Array(commandBuffers.length);
-        for (let i = 0; i < commandBuffers.length; i++) {
-            ptrs[i] = BigInt(commandBuffers[i]._native);
+    },
+    bufferUnmap(native, wrapper) {
+        wgpu.symbols.wgpuBufferUnmap(native);
+        wrapper._mapMode = 0;
+        wrapper._mappedWriteRanges = [];
+    },
+    bufferDestroy(native) {
+        wgpu.symbols.wgpuBufferRelease(native);
+    },
+    initQueueState(queue) {
+        queue._pendingSubmissions = 0;
+    },
+    queueHasPendingSubmissions(queue) {
+        return queue._pendingSubmissions > 0;
+    },
+    queueMarkSubmittedWorkDone(queue) {
+        queue._pendingSubmissions = 0;
+    },
+    queueSubmit(queue, queueNative, buffers) {
+        const deviceNative = assertLiveResource(queue._device, "GPUQueue.submit", "GPUDevice");
+        queue._pendingSubmissions += 1;
+        const dispatchFlush = wgpu.symbols.doeNativeComputeDispatchFlush;
+        if (dispatchFlush && buffers.length === 1 && buffers[0]?._batched) {
+            const cmds = buffers[0]._commands;
+            if (cmds.length >= 1 && cmds.length <= 2 && cmds[0]?.t === 0 && (cmds.length === 1 || cmds[1]?.t === 1)) {
+                const cmd0 = cmds[0];
+                const bgPtrs = new BigUint64Array(cmd0.bg.length);
+                for (let i = 0; i < cmd0.bg.length; i += 1) {
+                    bgPtrs[i] = BigInt(cmd0.bg[i] ?? 0);
+                }
+                const cmd1 = cmds.length === 2 ? cmds[1] : null;
+                dispatchFlush(
+                    queueNative, cmd0.p, bgPtrs, cmd0.bg.length,
+                    cmd0.x, cmd0.y, cmd0.z,
+                    cmd1?.s ?? null, BigInt(cmd1?.so ?? 0),
+                    cmd1?.d ?? null, BigInt(cmd1?.do ?? 0), BigInt(cmd1?.sz ?? 0));
+                if (cmd1) queue.markSubmittedWorkDone();
+                fastPathStats.dispatchFlush += 1;
+                return;
+            }
         }
-        wgpu.symbols.wgpuQueueSubmit(this._native, BigInt(commandBuffers.length), ptrs);
-        if (commandBuffers.length > 0) {
-            this._pendingSubmissions += commandBuffers.length;
+        if (buffers.every((cb) => cb?._batched && Array.isArray(cb._commands))) {
+            const allCommands = [];
+            for (const cb of buffers) allCommands.push(...cb._commands);
+            const encoder = wgpu.symbols.wgpuDeviceCreateCommandEncoder(deviceNative, null);
+            for (const cmd of allCommands) {
+                if (cmd.t === 0) {
+                    const pass = wgpu.symbols.wgpuCommandEncoderBeginComputePass(encoder, null);
+                    wgpu.symbols.wgpuComputePassEncoderSetPipeline(pass, cmd.p);
+                    for (let i = 0; i < cmd.bg.length; i += 1) {
+                        if (cmd.bg[i]) wgpu.symbols.wgpuComputePassEncoderSetBindGroup(pass, i, cmd.bg[i], BigInt(0), null);
+                    }
+                    wgpu.symbols.wgpuComputePassEncoderDispatchWorkgroups(pass, cmd.x, cmd.y, cmd.z);
+                    wgpu.symbols.wgpuComputePassEncoderEnd(pass);
+                    wgpu.symbols.wgpuComputePassEncoderRelease(pass);
+                } else if (cmd.t === 1) {
+                    wgpu.symbols.wgpuCommandEncoderCopyBufferToBuffer(
+                        encoder, cmd.s, BigInt(cmd.so), cmd.d, BigInt(cmd.do), BigInt(cmd.sz));
+                }
+            }
+            const cmdBuf = wgpu.symbols.wgpuCommandEncoderFinish(encoder, null);
+            const ptrs = new BigUint64Array([BigInt(cmdBuf)]);
+            wgpu.symbols.wgpuQueueSubmit(queueNative, BigInt(1), ptrs);
+            wgpu.symbols.wgpuCommandBufferRelease(cmdBuf);
+            wgpu.symbols.wgpuCommandEncoderRelease(encoder);
+            return;
         }
-    }
-
-    writeBuffer(buffer, bufferOffset, data, dataOffset = 0, size) {
-        let view = data;
-        if (dataOffset > 0 || size !== undefined) {
-            const byteOffset = data.byteOffset + dataOffset * (data.BYTES_PER_ELEMENT || 1);
-            const byteLength = size !== undefined
-                ? size * (data.BYTES_PER_ELEMENT || 1)
-                : data.byteLength - dataOffset * (data.BYTES_PER_ELEMENT || 1);
-            view = new Uint8Array(data.buffer, byteOffset, byteLength);
+        const ptrs = new BigUint64Array(buffers.length);
+        for (let index = 0; index < buffers.length; index += 1) {
+            ptrs[index] = BigInt(assertLiveResource(buffers[index], "GPUQueue.submit", "GPUCommandBuffer"));
         }
-        wgpu.symbols.wgpuQueueWriteBuffer(this._native, buffer._native, BigInt(bufferOffset), view, BigInt(view.byteLength));
-    }
-
-    async onSubmittedWorkDone() {
-        if (!this.hasPendingSubmissions()) return;
-        waitForSubmittedWorkDoneSync(this._instance, this._native);
-        this.markSubmittedWorkDone();
-    }
-}
-
-class DoeGPURenderPassEncoder {
-    constructor(native) { this._native = native; }
-
-    setPipeline(pipeline) {
-        wgpu.symbols.wgpuRenderPassEncoderSetPipeline(this._native, pipeline._native);
-    }
-
-    draw(vertexCount, instanceCount = 1, firstVertex = 0, firstInstance = 0) {
-        wgpu.symbols.wgpuRenderPassEncoderDraw(this._native, vertexCount, instanceCount, firstVertex, firstInstance);
-    }
-
-    end() {
-        wgpu.symbols.wgpuRenderPassEncoderEnd(this._native);
-    }
-}
-
-class DoeGPUTexture {
-    constructor(native) { this._native = native; }
-
-    createView(_descriptor) {
-        const view = wgpu.symbols.wgpuTextureCreateView(this._native, null);
-        return new DoeGPUTextureView(view);
-    }
-
-    destroy() {
-        wgpu.symbols.wgpuTextureRelease(this._native);
-        this._native = null;
-    }
-}
-
-class DoeGPUTextureView {
-    constructor(native) { this._native = native; }
-}
-
-class DoeGPUSampler {
-    constructor(native) { this._native = native; }
-}
-
-class DoeGPURenderPipeline {
-    constructor(native) { this._native = native; }
-}
-
-class DoeGPUShaderModule {
-    constructor(native, code) {
-        this._native = native;
-        this._code = code;
-    }
-}
-
-class DoeGPUComputePipeline {
-    constructor(native, device, explicitLayout, autoLayoutEntriesByGroup) {
-        this._native = native;
-        this._device = device;
-        this._explicitLayout = explicitLayout;
-        this._autoLayoutEntriesByGroup = autoLayoutEntriesByGroup;
-        this._cachedLayouts = new Map();
-    }
-
-    getBindGroupLayout(index) {
-        if (this._explicitLayout) return this._explicitLayout;
-        if (this._cachedLayouts.has(index)) return this._cachedLayouts.get(index);
-
-        let layout;
-        if (this._autoLayoutEntriesByGroup && process.platform === "darwin") {
-            const entries = this._autoLayoutEntriesByGroup.get(index) ?? [];
-            layout = this._device.createBindGroupLayout({ entries });
-        } else {
-            const native = process.platform === "darwin"
-                ? wgpu.symbols.doeNativeComputePipelineGetBindGroupLayout(this._native, index)
-                : wgpu.symbols.wgpuComputePipelineGetBindGroupLayout(this._native, index);
-            layout = new DoeGPUBindGroupLayout(native);
+        wgpu.symbols.wgpuQueueSubmit(queueNative, BigInt(buffers.length), ptrs);
+    },
+    queueWriteBuffer(_queue, native, bufferNative, bufferOffset, view) {
+        wgpu.symbols.wgpuQueueWriteBuffer(native, bufferNative, BigInt(bufferOffset), view, BigInt(view.byteLength));
+    },
+    async queueOnSubmittedWorkDone(queue, native) {
+        try {
+            waitForSubmittedWorkDoneSync(queue._instance, native);
+        } catch (error) {
+            if (error?.code === "DOE_QUEUE_UNAVAILABLE") {
+                return;
+            }
+            throw error;
         }
-
-        this._cachedLayouts.set(index, layout);
-        return layout;
-    }
-}
-
-class DoeGPUBindGroupLayout {
-    constructor(native) { this._native = native; }
-}
-
-class DoeGPUBindGroup {
-    constructor(native) { this._native = native; }
-}
-
-class DoeGPUPipelineLayout {
-    constructor(native) { this._native = native; }
-}
-
-class DoeGPUDevice {
-    constructor(native, instance) {
-        this._native = native;
-        this._instance = instance;
-        const q = wgpu.symbols.wgpuDeviceGetQueue(native);
-        this.queue = new DoeGPUQueue(q, instance);
-        this.limits = DOE_LIMITS;
-        this.features = DOE_FEATURES;
-    }
-
-    createBuffer(descriptor) {
-        const descBytes = buildBufferDescriptor(descriptor);
-        const buf = wgpu.symbols.wgpuDeviceCreateBuffer(this._native, descBytes);
-        return new DoeGPUBuffer(buf, this._instance, descriptor.size, descriptor.usage, this.queue);
-    }
-
-    createShaderModule(descriptor) {
-        const code = descriptor.code || descriptor.source;
-        if (!code) throw new Error("createShaderModule: descriptor.code is required");
+    },
+    textureCreateView(_texture, native) {
+        return wgpu.symbols.wgpuTextureCreateView(native, null);
+    },
+    textureDestroy(native) {
+        wgpu.symbols.wgpuTextureRelease(native);
+    },
+    shaderModuleDestroy(native) {
+        wgpu.symbols.wgpuShaderModuleRelease(native);
+    },
+    computePipelineGetBindGroupLayout(pipeline, index, classes) {
+        if (pipeline._autoLayoutEntriesByGroup && process.platform === "darwin") {
+            const entries = pipeline._autoLayoutEntriesByGroup.get(index) ?? [];
+            return pipeline._device.createBindGroupLayout({ entries });
+        }
+        const native = process.platform === "darwin"
+            ? wgpu.symbols.doeNativeComputePipelineGetBindGroupLayout(pipeline._native, index)
+            : wgpu.symbols.wgpuComputePipelineGetBindGroupLayout(pipeline._native, index);
+        return new classes.DoeGPUBindGroupLayout(native, pipeline._device);
+    },
+    deviceLimits,
+    deviceFeatures,
+    adapterLimits,
+    adapterFeatures,
+    preflightShaderSource,
+    requireAutoLayoutEntriesFromNative,
+    deviceGetQueue(native) {
+        return wgpu.symbols.wgpuDeviceGetQueue(native);
+    },
+    deviceCreateBuffer(device, validated) {
+        const descBytes = buildBufferDescriptor(validated);
+        return wgpu.symbols.wgpuDeviceCreateBuffer(assertLiveResource(device, "GPUDevice.createBuffer", "GPUDevice"), descBytes);
+    },
+    deviceCreateShaderModule(device, code) {
         const { desc, _refs } = buildShaderModuleDescriptor(code);
-        const mod = wgpu.symbols.wgpuDeviceCreateShaderModule(this._native, desc);
+        let mod;
+        try {
+            mod = wgpu.symbols.wgpuDeviceCreateShaderModule(assertLiveResource(device, "GPUDevice.createShaderModule", "GPUDevice"), desc);
+        } catch (error) {
+            throw enrichNativeCompilerError(error, "GPUDevice.createShaderModule", readLastErrorFields());
+        }
         void _refs;
-        return new DoeGPUShaderModule(mod, code);
-    }
-
-    createComputePipeline(descriptor) {
-        const shader = descriptor.compute?.module;
-        const entryPoint = descriptor.compute?.entryPoint || "main";
-        const layout = descriptor.layout === "auto" ? null : descriptor.layout;
-        const autoLayoutEntriesByGroup = layout ? null : inferAutoBindGroupLayouts(
-            shader?._code || "",
-            globals.GPUShaderStage.COMPUTE,
-        );
-        const { desc, _refs } = buildComputePipelineDescriptor(
-            shader._native, entryPoint, layout?._native ?? null);
-        const native = wgpu.symbols.wgpuDeviceCreateComputePipeline(this._native, desc);
+        if (!mod) {
+            throw compilerErrorFromMessage("GPUDevice.createShaderModule", nativeFailureMessage("createShaderModule failed"), readLastErrorFields());
+        }
+        return mod;
+    },
+    deviceCreateComputePipeline(device, shaderNative, entryPoint, layoutNative) {
+        const { desc, _refs } = buildComputePipelineDescriptor(shaderNative, entryPoint, layoutNative);
+        let native;
+        try {
+            native = wgpu.symbols.wgpuDeviceCreateComputePipeline(assertLiveResource(device, "GPUDevice.createComputePipeline", "GPUDevice"), desc);
+        } catch (error) {
+            throw enrichNativeCompilerError(error, "GPUDevice.createComputePipeline", readLastErrorFields());
+        }
         void _refs;
-        return new DoeGPUComputePipeline(native, this, layout, autoLayoutEntriesByGroup);
-    }
-
-    async createComputePipelineAsync(descriptor) {
-        return this.createComputePipeline(descriptor);
-    }
-
-    createBindGroupLayout(descriptor) {
-        const entries = (descriptor.entries || []).map((e) => ({
-            binding: e.binding,
-            visibility: e.visibility,
-            buffer: e.buffer ? {
-                type: e.buffer.type || "uniform",
-                hasDynamicOffset: e.buffer.hasDynamicOffset || false,
-                minBindingSize: e.buffer.minBindingSize || 0,
-            } : undefined,
-        }));
+        if (!native) {
+            throw compilerErrorFromMessage("GPUDevice.createComputePipeline", nativeFailureMessage("createComputePipeline failed"), readLastErrorFields());
+        }
+        return native;
+    },
+    deviceCreateBindGroupLayout(device, entries) {
         const { desc, _refs } = buildBindGroupLayoutDescriptor(entries);
-        const native = wgpu.symbols.wgpuDeviceCreateBindGroupLayout(this._native, desc);
+        const native = wgpu.symbols.wgpuDeviceCreateBindGroupLayout(assertLiveResource(device, "GPUDevice.createBindGroupLayout", "GPUDevice"), desc);
         void _refs;
-        return new DoeGPUBindGroupLayout(native);
-    }
-
-    createBindGroup(descriptor) {
-        const { desc, _refs } = buildBindGroupDescriptor(descriptor.layout._native, descriptor.entries || []);
-        const native = wgpu.symbols.wgpuDeviceCreateBindGroup(this._native, desc);
+        return native;
+    },
+    deviceCreateBindGroup(device, layoutNative, entries) {
+        const normalizedEntries = entries.map((entry) => ({
+            binding: entry.binding,
+            resource: entry.buffer
+                ? { buffer: entry.buffer, offset: entry.offset ?? 0, size: entry.size }
+                : entry.sampler
+                    ? { sampler: entry.sampler }
+                    : { textureView: entry.textureView },
+        }));
+        const { desc, _refs } = buildBindGroupDescriptor(layoutNative, normalizedEntries);
+        const native = wgpu.symbols.wgpuDeviceCreateBindGroup(assertLiveResource(device, "GPUDevice.createBindGroup", "GPUDevice"), desc);
         void _refs;
-        return new DoeGPUBindGroup(native);
-    }
-
-    createPipelineLayout(descriptor) {
-        const layouts = (descriptor.bindGroupLayouts || []).map((l) => l._native);
+        return native;
+    },
+    deviceCreatePipelineLayout(device, layouts) {
         const { desc, _refs } = buildPipelineLayoutDescriptor(layouts);
-        const native = wgpu.symbols.wgpuDeviceCreatePipelineLayout(this._native, desc);
+        const native = wgpu.symbols.wgpuDeviceCreatePipelineLayout(assertLiveResource(device, "GPUDevice.createPipelineLayout", "GPUDevice"), desc);
         void _refs;
-        return new DoeGPUPipelineLayout(native);
-    }
-
-    createTexture(descriptor) {
-        const descBytes = buildTextureDescriptor(descriptor);
-        const native = wgpu.symbols.wgpuDeviceCreateTexture(this._native, descBytes);
-        return new DoeGPUTexture(native);
-    }
-
-    createSampler(descriptor = {}) {
+        return native;
+    },
+    deviceCreateTexture(device, textureDescriptor, size, usage) {
+        const descBytes = buildTextureDescriptor({
+            ...textureDescriptor,
+            dimension: normalizeTextureDimension(textureDescriptor.dimension, "GPUDevice.createTexture"),
+            usage,
+            size,
+            mipLevelCount: assertIntegerInRange(textureDescriptor.mipLevelCount ?? 1, "GPUDevice.createTexture", "descriptor.mipLevelCount", { min: 1, max: UINT32_MAX }),
+        });
+        return wgpu.symbols.wgpuDeviceCreateTexture(assertLiveResource(device, "GPUDevice.createTexture", "GPUDevice"), descBytes);
+    },
+    deviceCreateSampler(device, descriptor) {
         const descBytes = buildSamplerDescriptor(descriptor);
-        const native = wgpu.symbols.wgpuDeviceCreateSampler(this._native, descBytes);
-        return new DoeGPUSampler(native);
-    }
-
-    createRenderPipeline(_descriptor) {
-        // Stub: descriptor is not marshaled yet (matches Node N-API stub).
-        const native = wgpu.symbols.wgpuDeviceCreateRenderPipeline(this._native, null);
-        return new DoeGPURenderPipeline(native);
-    }
-
-    createCommandEncoder(_descriptor) {
-        const native = wgpu.symbols.wgpuDeviceCreateCommandEncoder(this._native, null);
-        return new DoeGPUCommandEncoder(native);
-    }
-
-    destroy() {
-        wgpu.symbols.wgpuDeviceRelease(this._native);
-        this._native = null;
-    }
-}
-
-class DoeGPUAdapter {
-    constructor(native, instance) {
-        this._native = native;
-        this._instance = instance;
-        this.features = DOE_FEATURES;
-        this.limits = DOE_LIMITS;
-    }
-
-    async requestDevice(_descriptor) {
-        const device = requestDeviceSync(this._instance, this._native);
-        return new DoeGPUDevice(device, this._instance);
-    }
-
-    destroy() {
-        wgpu.symbols.wgpuAdapterRelease(this._native);
-        this._native = null;
-    }
-}
-
-class DoeGPU {
-    constructor(instance) {
-        this._instance = instance;
-    }
+        return wgpu.symbols.wgpuDeviceCreateSampler(assertLiveResource(device, "GPUDevice.createSampler", "GPUDevice"), descBytes);
+    },
+    deviceCreateRenderPipeline(device, descriptor) {
+        const { desc, _refs } = buildRenderPipelineDescriptor({
+            layout: descriptor.layout,
+            vertexModule: descriptor.vertexModule,
+            vertexEntryPoint: descriptor.vertexEntryPoint,
+            vertexBuffers: descriptor.vertexBuffers ?? [],
+            fragmentModule: descriptor.fragmentModule,
+            fragmentEntryPoint: descriptor.fragmentEntryPoint,
+            colorFormat: descriptor.colorFormat,
+            primitive: descriptor.primitive ?? null,
+            depthStencil: descriptor.depthStencil ?? null,
+            multisample: descriptor.multisample ?? null,
+        });
+        const native = wgpu.symbols.wgpuDeviceCreateRenderPipeline(
+            assertLiveResource(device, "GPUDevice.createRenderPipeline", "GPUDevice"),
+            desc,
+        );
+        void _refs;
+        if (!native) {
+            throw compilerErrorFromMessage("GPUDevice.createRenderPipeline", nativeFailureMessage("createRenderPipeline failed"));
+        }
+        return native;
+    },
+    deviceCreateQuerySet(device, descriptor) {
+        const QUERY_TYPE_TIMESTAMP = 2;
+        const fn = wgpu.symbols.doeNativeDeviceCreateQuerySet;
+        if (typeof fn !== "function") {
+            throw new Error("[fawn-webgpu] doeNativeDeviceCreateQuerySet not available");
+        }
+        const native = fn(
+            assertLiveResource(device, "GPUDevice.createQuerySet", "GPUDevice"),
+            QUERY_TYPE_TIMESTAMP,
+            descriptor.count,
+        );
+        if (!native) throw new Error("[fawn-webgpu] createQuerySet failed");
+        return native;
+    },
+    querySetDestroy(native) {
+        if (typeof wgpu.symbols.doeNativeQuerySetDestroy === "function") {
+            wgpu.symbols.doeNativeQuerySetDestroy(native);
+        }
+    },
+    deviceCreateCommandEncoder(device) {
+        return new DoeGPUCommandEncoder(null, device);
+    },
+    deviceDestroy(native) {
+        wgpu.symbols.wgpuDeviceRelease(native);
+    },
+    adapterRequestDevice(adapter, _descriptor, classes) {
+        const native = requestDeviceSync(adapter._instance, assertLiveResource(adapter, "GPUAdapter.requestDevice", "GPUAdapter"));
+        const device = {
+            _destroyed: false,
+            _resourceLabel: "GPUDevice",
+            _resourceOwner: null,
+            createBuffer: classes.DoeGPUDevice.prototype.createBuffer,
+            createShaderModule: classes.DoeGPUDevice.prototype.createShaderModule,
+            createComputePipeline: classes.DoeGPUDevice.prototype.createComputePipeline,
+            createComputePipelineAsync: classes.DoeGPUDevice.prototype.createComputePipelineAsync,
+            createBindGroupLayout: classes.DoeGPUDevice.prototype.createBindGroupLayout,
+            createBindGroup: classes.DoeGPUDevice.prototype.createBindGroup,
+            createPipelineLayout: classes.DoeGPUDevice.prototype.createPipelineLayout,
+            createTexture: classes.DoeGPUDevice.prototype.createTexture,
+            createSampler: classes.DoeGPUDevice.prototype.createSampler,
+            createRenderPipeline: classes.DoeGPUDevice.prototype.createRenderPipeline,
+            createQuerySet: classes.DoeGPUDevice.prototype.createQuerySet,
+            createCommandEncoder: classes.DoeGPUDevice.prototype.createCommandEncoder,
+            destroy: classes.DoeGPUDevice.prototype.destroy,
+        };
+        device._native = native;
+        device._instance = adapter._instance;
+        device.limits = deviceLimits(native);
+        device.features = deviceFeatures(native);
+        const queue = {
+            _destroyed: false,
+            _resourceLabel: "GPUQueue",
+            _resourceOwner: device,
+            hasPendingSubmissions: classes.DoeGPUQueue.prototype.hasPendingSubmissions,
+            markSubmittedWorkDone: classes.DoeGPUQueue.prototype.markSubmittedWorkDone,
+            submit: classes.DoeGPUQueue.prototype.submit,
+            writeBuffer: classes.DoeGPUQueue.prototype.writeBuffer,
+            onSubmittedWorkDone: classes.DoeGPUQueue.prototype.onSubmittedWorkDone,
+        };
+        queue._native = this.deviceGetQueue(native);
+        queue._instance = adapter._instance;
+        queue._device = device;
+        this.initQueueState(queue);
+        device.queue = queue;
+        return device;
+    },
+    adapterDestroy(native) {
+        wgpu.symbols.wgpuAdapterRelease(native);
+    },
+    gpuRequestAdapter(gpu, _options, classes) {
+        const adapter = requestAdapterSync(gpu._instance);
+        return new classes.DoeGPUAdapter(adapter, gpu._instance);
+    },
+};
 
-    async requestAdapter(_options) {
-        const adapter = requestAdapterSync(this._instance);
-        return new DoeGPUAdapter(adapter, this._instance);
-    }
-}
+const {
+    DoeGPUBuffer,
+    DoeGPUQueue,
+    DoeGPUTexture,
+    DoeGPUTextureView,
+    DoeGPUSampler,
+    DoeGPURenderPipeline,
+    DoeGPUShaderModule,
+    DoeGPUComputePipeline,
+    DoeGPUBindGroupLayout,
+    DoeGPUBindGroup,
+    DoeGPUPipelineLayout,
+    DoeGPUDevice,
+    DoeGPUAdapter,
+    DoeGPU,
+} = createFullSurfaceClasses({
+    globals,
+    backend: fullSurfaceBackend,
+});
 
 // ---------------------------------------------------------------------------
 // Library initialization
@@ -1061,57 +1842,21 @@ export function create(createArgs = null) {
 }
 
 export function setupGlobals(target = globalThis, createArgs = null) {
-    for (const [name, value] of Object.entries(globals)) {
-        if (target[name] === undefined) {
-            Object.defineProperty(target, name, {
-                value,
-                writable: true,
-                configurable: true,
-                enumerable: false,
-            });
-        }
-    }
     const gpu = create(createArgs);
-    if (typeof target.navigator === "undefined") {
-        Object.defineProperty(target, "navigator", {
-            value: { gpu },
-            writable: true,
-            configurable: true,
-            enumerable: false,
-        });
-    } else if (!target.navigator.gpu) {
-        Object.defineProperty(target.navigator, "gpu", {
-            value: gpu,
-            writable: true,
-            configurable: true,
-            enumerable: false,
-        });
-    }
-    return gpu;
+    return setupGlobalsOnTarget(target, gpu, globals);
 }
 
 export async function requestAdapter(adapterOptions = undefined, createArgs = null) {
-    const gpu = create(createArgs);
-    return gpu.requestAdapter(adapterOptions);
+    return requestAdapterFromCreate(create, adapterOptions, createArgs);
 }
 
 export async function requestDevice(options = {}) {
-    const createArgs = options?.createArgs ?? null;
-    const adapter = await requestAdapter(options?.adapterOptions, createArgs);
-    return adapter.requestDevice(options?.deviceDescriptor);
-}
-
-function libraryFlavor(libraryPath) {
-    if (!libraryPath) return "missing";
-    if (/libwebgpu_doe\.(so|dylib|dll)$/.test(libraryPath)) return "doe-dropin";
-    if (/lib(webgpu|webgpu_dawn|wgpu_native)\.(so|dylib|dll)/.test(libraryPath)) return "delegate";
-    return "unknown";
+    return requestDeviceFromRequestAdapter(requestAdapter, options);
 }
 
 export function providerInfo() {
     const flavor = DOE_LIBRARY_FLAVOR;
-    return {
-        module: "@simulatte/webgpu",
+    return buildProviderInfo({
         loaded: !!DOE_LIB_PATH,
         loadError: !DOE_LIB_PATH ? "libwebgpu_doe not found" : "",
         defaultCreateArgs: [],
@@ -1122,10 +1867,17 @@ export function providerInfo() {
         buildMetadataPath: DOE_BUILD_METADATA.path,
         leanVerifiedBuild: DOE_BUILD_METADATA.leanVerifiedBuild,
         proofArtifactSha256: DOE_BUILD_METADATA.proofArtifactSha256,
-    };
+    });
 }
 
 export { createDoeRuntime, runDawnVsDoeCompare };
+export { preflightShaderSource };
+export { fastPathStats };
+
+export function setNativeTimeoutMs(timeoutMs) {
+    validatePositiveInteger(timeoutMs, 'native timeout');
+    processEventsTimeoutNs = timeoutMs * 1_000_000;
+}
 
 export default {
     create,
@@ -1134,6 +1886,9 @@ export default {
     requestAdapter,
     requestDevice,
     providerInfo,
+    preflightShaderSource,
+    setNativeTimeoutMs,
     createDoeRuntime,
     runDawnVsDoeCompare,
+    fastPathStats,
 };