@simulatte/webgpu 0.3.1 → 0.3.2

package/native/doe_napi.c

@@ -62,11 +62,13 @@ typedef uint32_t WGPUBool;
 #define WGPU_WAIT_STATUS_SUCCESS 1
 #define WGPU_WAIT_STATUS_TIMED_OUT 2
 #define WGPU_WAIT_STATUS_ERROR 3
+#define WGPU_STATUS_SUCCESS 1
 #define WGPU_MAP_ASYNC_STATUS_SUCCESS 1
 #define WGPU_REQUEST_STATUS_SUCCESS 1
 #define WGPU_CALLBACK_MODE_ALLOW_PROCESS_EVENTS 2
 #define DOE_DEFAULT_TIMEOUT_NS 2000000000ULL
 #define DOE_WAIT_SLICE_NS 1000ULL
+#define DOE_ERROR_BUF_CAP 512
 
 typedef struct { uint64_t id; } WGPUFuture;
 typedef struct { const char* data; size_t length; } WGPUStringView;
@@ -187,6 +189,14 @@ typedef struct {
     uint32_t immediateSize;
 } WGPUPipelineLayoutDescriptor;
 
+typedef struct {
+    uint32_t group;
+    uint32_t binding;
+    uint32_t kind;
+    uint32_t addr_space;
+    uint32_t access;
+} DoeShaderBindingInfo;
+
 typedef struct {
     void* nextInChain;
     WGPUStringView label;
@@ -199,6 +209,30 @@ typedef struct {
     uint32_t depthOrArrayLayers;
 } WGPUExtent3D;
 
+typedef struct {
+    uint32_t x;
+    uint32_t y;
+    uint32_t z;
+} WGPUOrigin3D;
+
+typedef struct {
+    uint64_t offset;
+    uint32_t bytesPerRow;
+    uint32_t rowsPerImage;
+} WGPUTexelCopyBufferLayout;
+
+typedef struct {
+    WGPUTexelCopyBufferLayout layout;
+    WGPUBuffer buffer;
+} WGPUTexelCopyBufferInfo;
+
+typedef struct {
+    WGPUTexture texture;
+    uint32_t mipLevel;
+    WGPUOrigin3D origin;
+    uint32_t aspect;
+} WGPUTexelCopyTextureInfo;
+
 typedef struct {
     void* nextInChain;
     WGPUStringView label;
@@ -252,6 +286,19 @@ typedef struct {
     WGPUColor clearValue;
 } WGPURenderPassColorAttachment;
 
+typedef struct {
+    void* nextInChain;
+    WGPUTextureView view;
+    uint32_t depthLoadOp;
+    uint32_t depthStoreOp;
+    float depthClearValue;
+    WGPUBool depthReadOnly;
+    uint32_t stencilLoadOp;
+    uint32_t stencilStoreOp;
+    uint32_t stencilClearValue;
+    WGPUBool stencilReadOnly;
+} WGPURenderPassDepthStencilAttachment;
+
 typedef struct {
     void* nextInChain;
     WGPUStringView label;
@@ -262,6 +309,102 @@ typedef struct {
     void* timestampWrites;
 } WGPURenderPassDescriptor;
 
+typedef struct {
+    void* nextInChain;
+    WGPUStringView key;
+    double value;
+} WGPUConstantEntry;
+
+typedef struct {
+    void* nextInChain;
+    WGPUShaderModule module;
+    WGPUStringView entryPoint;
+    size_t constantCount;
+    const WGPUConstantEntry* constants;
+    size_t bufferCount;
+    const void* buffers;
+} WGPURenderVertexState;
+
+typedef struct {
+    void* nextInChain;
+    uint32_t format;
+    uint64_t offset;
+    uint32_t shaderLocation;
+} WGPURenderVertexAttribute;
+
+typedef struct {
+    void* nextInChain;
+    uint32_t stepMode;
+    uint64_t arrayStride;
+    size_t attributeCount;
+    const WGPURenderVertexAttribute* attributes;
+} WGPURenderVertexBufferLayout;
+
+typedef struct {
+    void* nextInChain;
+    uint32_t format;
+    const void* blend;
+    uint64_t writeMask;
+} WGPURenderColorTargetState;
+
+typedef struct {
+    void* nextInChain;
+    WGPUShaderModule module;
+    WGPUStringView entryPoint;
+    size_t constantCount;
+    const WGPUConstantEntry* constants;
+    size_t targetCount;
+    const WGPURenderColorTargetState* targets;
+} WGPURenderFragmentState;
+
+typedef struct {
+    void* nextInChain;
+    uint32_t topology;
+    uint32_t stripIndexFormat;
+    uint32_t frontFace;
+    uint32_t cullMode;
+    WGPUBool unclippedDepth;
+} WGPURenderPrimitiveState;
+
+typedef struct {
+    void* nextInChain;
+    uint32_t count;
+    uint32_t mask;
+    WGPUBool alphaToCoverageEnabled;
+} WGPURenderMultisampleState;
+
+typedef struct {
+    uint32_t compare;
+    uint32_t failOp;
+    uint32_t depthFailOp;
+    uint32_t passOp;
+} WGPURenderStencilFaceState;
+
+typedef struct {
+    void* nextInChain;
+    uint32_t format;
+    uint32_t depthWriteEnabled;
+    uint32_t depthCompare;
+    WGPURenderStencilFaceState stencilFront;
+    WGPURenderStencilFaceState stencilBack;
+    uint32_t stencilReadMask;
+    uint32_t stencilWriteMask;
+    int32_t depthBias;
+    float depthBiasSlopeScale;
+    float depthBiasClamp;
+} WGPURenderDepthStencilState;
+
+typedef struct {
+    void* nextInChain;
+    WGPUStringView label;
+    WGPUPipelineLayout layout;
+    WGPURenderVertexState vertex;
+    WGPURenderPrimitiveState primitive;
+    const WGPURenderDepthStencilState* depthStencil;
+    WGPURenderMultisampleState multisample;
+    const WGPURenderFragmentState* fragment;
+} WGPURenderPipelineDescriptor;
+
 typedef struct {
     void*    nextInChain;
     uint32_t maxTextureDimension1D;
@@ -357,9 +500,11 @@ DECL_PFN(uint32_t, wgpuInstanceWaitAny, (WGPUInstance, size_t, WGPUFutureWaitInf
 DECL_PFN(void, wgpuInstanceProcessEvents, (WGPUInstance));
 DECL_PFN(void, wgpuAdapterRelease, (WGPUAdapter));
 DECL_PFN(WGPUBool, wgpuAdapterHasFeature, (WGPUAdapter, uint32_t));
+DECL_PFN(uint32_t, wgpuAdapterGetLimits, (WGPUAdapter, void*));
 DECL_PFN(WGPUFuture, wgpuAdapterRequestDevice, (WGPUAdapter, const void*, WGPURequestDeviceCallbackInfo));
 DECL_PFN(void, wgpuDeviceRelease, (WGPUDevice));
 DECL_PFN(WGPUBool, wgpuDeviceHasFeature, (WGPUDevice, uint32_t));
+DECL_PFN(uint32_t, wgpuDeviceGetLimits, (WGPUDevice, void*));
 DECL_PFN(WGPUQueue, wgpuDeviceGetQueue, (WGPUDevice));
 DECL_PFN(WGPUBuffer, wgpuDeviceCreateBuffer, (WGPUDevice, const WGPUBufferDescriptor*));
 DECL_PFN(WGPUShaderModule, wgpuDeviceCreateShaderModule, (WGPUDevice, const WGPUShaderModuleDescriptor*));
@@ -377,6 +522,8 @@ DECL_PFN(WGPUCommandEncoder, wgpuDeviceCreateCommandEncoder, (WGPUDevice, const
 DECL_PFN(void, wgpuCommandEncoderRelease, (WGPUCommandEncoder));
 DECL_PFN(WGPUComputePassEncoder, wgpuCommandEncoderBeginComputePass, (WGPUCommandEncoder, const WGPUComputePassDescriptor*));
 DECL_PFN(void, wgpuCommandEncoderCopyBufferToBuffer, (WGPUCommandEncoder, WGPUBuffer, uint64_t, WGPUBuffer, uint64_t, uint64_t));
+DECL_PFN(void, wgpuCommandEncoderCopyTextureToBuffer, (WGPUCommandEncoder, const WGPUTexelCopyTextureInfo*, const WGPUTexelCopyBufferInfo*, const WGPUExtent3D*));
+DECL_PFN(void, doeNativeCommandEncoderCopyTextureToBuffer, (WGPUCommandEncoder, WGPUTexture, uint32_t, WGPUBuffer, uint64_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t));
 DECL_PFN(WGPUCommandBuffer, wgpuCommandEncoderFinish, (WGPUCommandEncoder, const WGPUCommandBufferDescriptor*));
 DECL_PFN(void, wgpuComputePassEncoderSetPipeline, (WGPUComputePassEncoder, WGPUComputePipeline));
 DECL_PFN(void, wgpuComputePassEncoderSetBindGroup, (WGPUComputePassEncoder, uint32_t, WGPUBindGroup, size_t, const uint32_t*));
@@ -403,10 +550,25 @@ DECL_PFN(WGPURenderPipeline, wgpuDeviceCreateRenderPipeline, (WGPUDevice, const
 DECL_PFN(void, wgpuRenderPipelineRelease, (WGPURenderPipeline));
 DECL_PFN(WGPURenderPassEncoder, wgpuCommandEncoderBeginRenderPass, (WGPUCommandEncoder, const WGPURenderPassDescriptor*));
 DECL_PFN(void, wgpuRenderPassEncoderSetPipeline, (WGPURenderPassEncoder, WGPURenderPipeline));
+DECL_PFN(void, wgpuRenderPassEncoderSetBindGroup, (WGPURenderPassEncoder, uint32_t, WGPUBindGroup, size_t, const uint32_t*));
+DECL_PFN(void, wgpuRenderPassEncoderSetVertexBuffer, (WGPURenderPassEncoder, uint32_t, WGPUBuffer, uint64_t, uint64_t));
+DECL_PFN(void, wgpuRenderPassEncoderSetIndexBuffer, (WGPURenderPassEncoder, WGPUBuffer, uint32_t, uint64_t, uint64_t));
 DECL_PFN(void, wgpuRenderPassEncoderDraw, (WGPURenderPassEncoder, uint32_t, uint32_t, uint32_t, uint32_t));
+DECL_PFN(void, wgpuRenderPassEncoderDrawIndexed, (WGPURenderPassEncoder, uint32_t, uint32_t, uint32_t, int32_t, uint32_t));
 DECL_PFN(void, wgpuRenderPassEncoderEnd, (WGPURenderPassEncoder));
 DECL_PFN(void, wgpuRenderPassEncoderRelease, (WGPURenderPassEncoder));
-DECL_PFN(uint32_t, wgpuDeviceGetLimits, (WGPUDevice, void*));
+DECL_PFN(uint32_t, doeNativeAdapterGetLimits, (WGPUAdapter, void*));
+DECL_PFN(uint32_t, doeNativeDeviceGetLimits, (WGPUDevice, void*));
+DECL_PFN(uint32_t, doeNativeAdapterHasFeature, (WGPUAdapter, uint32_t));
+DECL_PFN(uint32_t, doeNativeDeviceHasFeature, (WGPUDevice, uint32_t));
+DECL_PFN(size_t, doeNativeCopyLastErrorMessage, (char*, size_t));
+DECL_PFN(size_t, doeNativeCopyLastErrorStage, (char*, size_t));
+DECL_PFN(size_t, doeNativeCopyLastErrorKind, (char*, size_t));
+DECL_PFN(uint32_t, doeNativeGetLastErrorLine, (void));
+DECL_PFN(uint32_t, doeNativeGetLastErrorColumn, (void));
+DECL_PFN(uint32_t, doeNativeCheckShaderSource, (const char*, size_t));
+DECL_PFN(size_t, doeNativeShaderModuleGetBindings, (WGPUShaderModule, DoeShaderBindingInfo*, size_t));
+DECL_PFN(WGPUFuture, doeNativeAdapterRequestDevice, (WGPUAdapter, const void*, WGPURequestDeviceCallbackInfo));
 
 /* Flat helpers are optional. When absent, the addon assembles the callback-info
  * structs directly and calls the standard WebGPU request entrypoints. */
@@ -414,6 +576,10 @@ DECL_PFN(WGPUFuture, doeRequestAdapterFlat, (WGPUInstance, const void*, uint32_t
 DECL_PFN(WGPUFuture, doeRequestDeviceFlat, (WGPUAdapter, const void*, uint32_t, WGPURequestDeviceCallback, void*, void*));
 DECL_PFN(void, doeNativeQueueFlush, (void*));
 DECL_PFN(void, doeNativeComputeDispatchFlush, (void*, void*, void**, uint32_t, uint32_t, uint32_t, uint32_t, void*, uint64_t, void*, uint64_t, uint64_t));
+DECL_PFN(WGPUQuerySet, doeNativeDeviceCreateQuerySet, (WGPUDevice, uint32_t, uint32_t));
+DECL_PFN(void, doeNativeCommandEncoderWriteTimestamp, (WGPUCommandEncoder, WGPUQuerySet, uint32_t));
+DECL_PFN(void, doeNativeCommandEncoderResolveQuerySet, (WGPUCommandEncoder, WGPUQuerySet, uint32_t, uint32_t, WGPUBuffer, uint64_t));
+DECL_PFN(void, doeNativeQuerySetDestroy, (WGPUQuerySet));
 typedef struct {
     void* nextInChain;
     uint32_t mode;
@@ -426,6 +592,25 @@ typedef WGPUFuture (*PFN_wgpuBufferMapAsync2)(WGPUBuffer, uint64_t, size_t, size
 static PFN_wgpuBufferMapAsync2 pfn_wgpuBufferMapAsync2 = NULL;
 
 static void* g_lib = NULL;
+static uint64_t g_timeout_ns = DOE_DEFAULT_TIMEOUT_NS;
+
+static uint64_t current_timeout_ns(void) {
+    return g_timeout_ns;
+}
+
+static void copy_library_error_message(char* out, size_t out_len) {
+    if (!out || out_len == 0) return;
+    out[0] = '\0';
+    if (!pfn_doeNativeCopyLastErrorMessage) return;
+    pfn_doeNativeCopyLastErrorMessage(out, out_len);
+}
+
+static void copy_library_error_meta(PFN_doeNativeCopyLastErrorMessage fn, char* out, size_t out_len) {
+    if (!out || out_len == 0) return;
+    out[0] = '\0';
+    if (!fn) return;
+    fn(out, out_len);
+}
 
 static uint64_t monotonic_now_ns(void) {
 #ifdef _WIN32
@@ -463,12 +648,33 @@ static int process_events_until(WGPUInstance inst, volatile uint32_t* done, uint
     return 1;
 }
 
+static void copy_string_view_message(WGPUStringView message, char* out, size_t out_len) {
+    if (!out || out_len == 0) return;
+    out[0] = '\0';
+    if (!message.data || message.length == 0) return;
+    size_t copy_len = message.length;
+    if (copy_len >= out_len) copy_len = out_len - 1;
+    memcpy(out, message.data, copy_len);
+    out[copy_len] = '\0';
+}
+
+static napi_value throw_status_error(napi_env env, const char* code, const char* prefix, uint32_t status, const char* detail) {
+    char msg[DOE_ERROR_BUF_CAP];
+    if (detail && detail[0] != '\0') {
+        snprintf(msg, sizeof(msg), "%s (status=%u, detail=%s)", prefix, status, detail);
+    } else {
+        snprintf(msg, sizeof(msg), "%s (status=%u)", prefix, status);
+    }
+    napi_throw_error(env, code, msg);
+    return NULL;
+}
+
 /* ================================================================
  * N-API utility helpers
  * ================================================================ */
 
-#define NAPI_THROW(env, msg) do { napi_throw_error(env, NULL, msg); return NULL; } while(0)
-#define MAX_NAPI_ARGS 8
+#define NAPI_THROW(env, msg) do { napi_throw_error(env, "DOE_ERROR", msg); return NULL; } while(0)
+#define MAX_NAPI_ARGS 16
 #define NAPI_ASSERT_ARGC(env, info, n) \
     size_t _argc = (n); napi_value _args[MAX_NAPI_ARGS]; \
     if ((n) > MAX_NAPI_ARGS) NAPI_THROW(env, "too many args"); \
@@ -514,6 +720,20 @@ static int64_t get_int64_prop(napi_env env, napi_value obj, const char* key) {
     return out;
 }
 
+static int64_t get_int64_value(napi_env env, napi_value value) {
+    int64_t out = 0;
+    napi_get_value_int64(env, value, &out);
+    return out;
+}
+
+static double get_double_prop(napi_env env, napi_value obj, const char* key) {
+    napi_value val;
+    napi_get_named_property(env, obj, key, &val);
+    double out = 0.0;
+    napi_get_value_double(env, val, &out);
+    return out;
+}
+
 static bool get_bool_prop(napi_env env, napi_value obj, const char* key) {
     napi_value val;
     napi_get_named_property(env, obj, key, &val);
@@ -537,6 +757,16 @@ static napi_value get_prop(napi_env env, napi_value obj, const char* key) {
     return val;
 }
 
+static char* dup_string_value(napi_env env, napi_value value, size_t* out_len) {
+    size_t len = 0;
+    napi_get_value_string_utf8(env, value, NULL, 0, &len);
+    char* out = (char*)malloc(len + 1);
+    if (!out) return NULL;
+    napi_get_value_string_utf8(env, value, out, len + 1, &len);
+    if (out_len) *out_len = len;
+    return out;
+}
+
 static napi_valuetype prop_type(napi_env env, napi_value obj, const char* key) {
     napi_value val;
     napi_get_named_property(env, obj, key, &val);
@@ -563,6 +793,15 @@ static napi_value doe_load_library(napi_env env, napi_callback_info info) {
     free(path);
     if (!g_lib) NAPI_THROW(env, "Failed to load libwebgpu_doe");
 
+    const char* timeout_env = getenv("DOE_TIMEOUT_MS");
+    if (timeout_env && timeout_env[0] != '\0') {
+        char* end = NULL;
+        unsigned long parsed = strtoul(timeout_env, &end, 10);
+        if (end && *end == '\0') {
+            g_timeout_ns = (uint64_t)parsed * 1000000ULL;
+        }
+    }
+
     LOAD_SYM(wgpuCreateInstance);
     LOAD_SYM(wgpuInstanceRelease);
     LOAD_SYM(wgpuInstanceRequestAdapter);
@@ -570,6 +809,7 @@ static napi_value doe_load_library(napi_env env, napi_callback_info info) {
     LOAD_SYM(wgpuInstanceProcessEvents);
     LOAD_SYM(wgpuAdapterRelease);
     LOAD_SYM(wgpuAdapterHasFeature);
+    LOAD_SYM(wgpuAdapterGetLimits);
     LOAD_SYM(wgpuAdapterRequestDevice);
     LOAD_SYM(wgpuDeviceRelease);
     LOAD_SYM(wgpuDeviceHasFeature);
@@ -590,6 +830,8 @@ static napi_value doe_load_library(napi_env env, napi_callback_info info) {
     LOAD_SYM(wgpuCommandEncoderRelease);
     LOAD_SYM(wgpuCommandEncoderBeginComputePass);
     LOAD_SYM(wgpuCommandEncoderCopyBufferToBuffer);
+    LOAD_SYM(wgpuCommandEncoderCopyTextureToBuffer);
+    LOAD_SYM(doeNativeCommandEncoderCopyTextureToBuffer);
     LOAD_SYM(wgpuCommandEncoderFinish);
     LOAD_SYM(wgpuComputePassEncoderSetPipeline);
     LOAD_SYM(wgpuComputePassEncoderSetBindGroup);
@@ -616,15 +858,38 @@ static napi_value doe_load_library(napi_env env, napi_callback_info info) {
     LOAD_SYM(wgpuRenderPipelineRelease);
     LOAD_SYM(wgpuCommandEncoderBeginRenderPass);
     LOAD_SYM(wgpuRenderPassEncoderSetPipeline);
+    LOAD_SYM(wgpuRenderPassEncoderSetBindGroup);
+    LOAD_SYM(wgpuRenderPassEncoderSetVertexBuffer);
+    LOAD_SYM(wgpuRenderPassEncoderSetIndexBuffer);
     LOAD_SYM(wgpuRenderPassEncoderDraw);
+    LOAD_SYM(wgpuRenderPassEncoderDrawIndexed);
     LOAD_SYM(wgpuRenderPassEncoderEnd);
     LOAD_SYM(wgpuRenderPassEncoderRelease);
+    LOAD_SYM(wgpuAdapterGetLimits);
+    LOAD_SYM(wgpuAdapterHasFeature);
+    LOAD_SYM(wgpuDeviceHasFeature);
     LOAD_SYM(wgpuDeviceGetLimits);
+    pfn_doeNativeAdapterGetLimits = (PFN_doeNativeAdapterGetLimits)LIB_SYM(g_lib, "doeNativeAdapterGetLimits");
+    pfn_doeNativeDeviceGetLimits = (PFN_doeNativeDeviceGetLimits)LIB_SYM(g_lib, "doeNativeDeviceGetLimits");
+    pfn_doeNativeAdapterHasFeature = (PFN_doeNativeAdapterHasFeature)LIB_SYM(g_lib, "doeNativeAdapterHasFeature");
+    pfn_doeNativeDeviceHasFeature = (PFN_doeNativeDeviceHasFeature)LIB_SYM(g_lib, "doeNativeDeviceHasFeature");
+    pfn_doeNativeCopyLastErrorMessage = (PFN_doeNativeCopyLastErrorMessage)LIB_SYM(g_lib, "doeNativeCopyLastErrorMessage");
+    pfn_doeNativeCopyLastErrorStage = (PFN_doeNativeCopyLastErrorStage)LIB_SYM(g_lib, "doeNativeCopyLastErrorStage");
+    pfn_doeNativeCopyLastErrorKind = (PFN_doeNativeCopyLastErrorKind)LIB_SYM(g_lib, "doeNativeCopyLastErrorKind");
+    pfn_doeNativeGetLastErrorLine = (PFN_doeNativeGetLastErrorLine)LIB_SYM(g_lib, "doeNativeGetLastErrorLine");
+    pfn_doeNativeGetLastErrorColumn = (PFN_doeNativeGetLastErrorColumn)LIB_SYM(g_lib, "doeNativeGetLastErrorColumn");
+    pfn_doeNativeCheckShaderSource = (PFN_doeNativeCheckShaderSource)LIB_SYM(g_lib, "doeNativeCheckShaderSource");
+    pfn_doeNativeShaderModuleGetBindings = (PFN_doeNativeShaderModuleGetBindings)LIB_SYM(g_lib, "doeNativeShaderModuleGetBindings");
+    pfn_doeNativeAdapterRequestDevice = (PFN_doeNativeAdapterRequestDevice)LIB_SYM(g_lib, "doeNativeAdapterRequestDevice");
     pfn_doeRequestAdapterFlat = (PFN_doeRequestAdapterFlat)LIB_SYM(g_lib, "doeRequestAdapterFlat");
     pfn_doeRequestDeviceFlat = (PFN_doeRequestDeviceFlat)LIB_SYM(g_lib, "doeRequestDeviceFlat");
     pfn_wgpuBufferMapAsync2 = (PFN_wgpuBufferMapAsync2)LIB_SYM(g_lib, "wgpuBufferMapAsync");
     pfn_doeNativeQueueFlush = (PFN_doeNativeQueueFlush)LIB_SYM(g_lib, "doeNativeQueueFlush");
     pfn_doeNativeComputeDispatchFlush = (PFN_doeNativeComputeDispatchFlush)LIB_SYM(g_lib, "doeNativeComputeDispatchFlush");
+    pfn_doeNativeDeviceCreateQuerySet = (PFN_doeNativeDeviceCreateQuerySet)LIB_SYM(g_lib, "doeNativeDeviceCreateQuerySet");
+    pfn_doeNativeCommandEncoderWriteTimestamp = (PFN_doeNativeCommandEncoderWriteTimestamp)LIB_SYM(g_lib, "doeNativeCommandEncoderWriteTimestamp");
+    pfn_doeNativeCommandEncoderResolveQuerySet = (PFN_doeNativeCommandEncoderResolveQuerySet)LIB_SYM(g_lib, "doeNativeCommandEncoderResolveQuerySet");
+    pfn_doeNativeQuerySetDestroy = (PFN_doeNativeQuerySetDestroy)LIB_SYM(g_lib, "doeNativeQuerySetDestroy");
 
     /* Validate all critical function pointers were resolved. */
     if (!pfn_wgpuCreateInstance || !pfn_wgpuInstanceRelease || !pfn_wgpuInstanceRequestAdapter ||
@@ -674,14 +939,16 @@ typedef struct {
     uint32_t status;
     WGPUAdapter adapter;
     uint32_t done;
+    char message[DOE_ERROR_BUF_CAP];
 } AdapterRequestResult;
 
 static void adapter_callback(uint32_t status, WGPUAdapter adapter,
     WGPUStringView message, void* userdata1, void* userdata2) {
-    (void)message; (void)userdata2;
+    (void)userdata2;
     AdapterRequestResult* r = (AdapterRequestResult*)userdata1;
     r->status = status;
     r->adapter = adapter;
+    copy_string_view_message(message, r->message, sizeof(r->message));
     r->done = 1;
 }
 
@@ -691,7 +958,7 @@ static napi_value doe_request_adapter(napi_env env, napi_callback_info info) {
     WGPUInstance inst = unwrap_ptr(env, _args[0]);
     if (!inst) NAPI_THROW(env, "Invalid instance");
 
-    AdapterRequestResult result = {0, NULL, 0};
+    AdapterRequestResult result = {0};
     WGPUFuture future;
     if (pfn_doeRequestAdapterFlat) {
         future = pfn_doeRequestAdapterFlat(
@@ -707,9 +974,10 @@ static napi_value doe_request_adapter(napi_env env, napi_callback_info info) {
         future = pfn_wgpuInstanceRequestAdapter(inst, NULL, callback_info);
     }
     if (future.id == 0) NAPI_THROW(env, "requestAdapter future unavailable");
-    if (!process_events_until(inst, &result.done, DOE_DEFAULT_TIMEOUT_NS) ||
-        result.status != WGPU_REQUEST_STATUS_SUCCESS || !result.adapter)
-        NAPI_THROW(env, "requestAdapter failed");
+    if (!process_events_until(inst, &result.done, current_timeout_ns()))
+        return throw_status_error(env, "DOE_REQUEST_ADAPTER_TIMEOUT", "requestAdapter timed out", result.status, result.message);
+    if (result.status != WGPU_REQUEST_STATUS_SUCCESS || !result.adapter)
+        return throw_status_error(env, "DOE_REQUEST_ADAPTER_ERROR", "requestAdapter failed", result.status, result.message);
 
     return wrap_ptr(env, result.adapter);
 }
@@ -729,14 +997,16 @@ typedef struct {
     uint32_t status;
     WGPUDevice device;
     uint32_t done;
+    char message[DOE_ERROR_BUF_CAP];
 } DeviceRequestResult;
 
 static void device_callback(uint32_t status, WGPUDevice device,
     WGPUStringView message, void* userdata1, void* userdata2) {
-    (void)message; (void)userdata2;
+    (void)userdata2;
     DeviceRequestResult* r = (DeviceRequestResult*)userdata1;
     r->status = status;
     r->device = device;
+    copy_string_view_message(message, r->message, sizeof(r->message));
     r->done = 1;
 }
 
@@ -747,25 +1017,22 @@ static napi_value doe_request_device(napi_env env, napi_callback_info info) {
     WGPUAdapter adapter = unwrap_ptr(env, _args[1]);
     if (!inst || !adapter) NAPI_THROW(env, "Invalid instance or adapter");
 
-    DeviceRequestResult result = {0, NULL, 0};
-    WGPUFuture future;
-    if (pfn_doeRequestDeviceFlat) {
-        future = pfn_doeRequestDeviceFlat(
-            adapter, NULL, WGPU_CALLBACK_MODE_ALLOW_PROCESS_EVENTS, device_callback, &result, NULL);
-    } else {
-        const WGPURequestDeviceCallbackInfo callback_info = {
-            .nextInChain = NULL,
-            .mode = WGPU_CALLBACK_MODE_ALLOW_PROCESS_EVENTS,
-            .callback = device_callback,
-            .userdata1 = &result,
-            .userdata2 = NULL,
-        };
-        future = pfn_wgpuAdapterRequestDevice(adapter, NULL, callback_info);
-    }
+    DeviceRequestResult result = {0};
+    const WGPURequestDeviceCallbackInfo callback_info = {
+        .nextInChain = NULL,
+        .mode = WGPU_CALLBACK_MODE_ALLOW_PROCESS_EVENTS,
+        .callback = device_callback,
+        .userdata1 = &result,
+        .userdata2 = NULL,
+    };
+    WGPUFuture future = pfn_doeNativeAdapterRequestDevice
+        ? pfn_doeNativeAdapterRequestDevice(adapter, NULL, callback_info)
+        : pfn_wgpuAdapterRequestDevice(adapter, NULL, callback_info);
     if (future.id == 0) NAPI_THROW(env, "requestDevice future unavailable");
-    if (!process_events_until(inst, &result.done, DOE_DEFAULT_TIMEOUT_NS) ||
-        result.status != WGPU_REQUEST_STATUS_SUCCESS || !result.device)
-        NAPI_THROW(env, "requestDevice failed");
+    if (!process_events_until(inst, &result.done, current_timeout_ns()))
+        return throw_status_error(env, "DOE_REQUEST_DEVICE_TIMEOUT", "requestDevice timed out", result.status, result.message);
+    if (result.status != WGPU_REQUEST_STATUS_SUCCESS || !result.device)
+        return throw_status_error(env, "DOE_REQUEST_DEVICE_ERROR", "requestDevice failed", result.status, result.message);
 
     return wrap_ptr(env, result.device);
 }
@@ -824,26 +1091,30 @@ static napi_value doe_buffer_unmap(napi_env env, napi_callback_info info) {
 typedef struct {
     uint32_t status;
     uint32_t done;
+    char message[DOE_ERROR_BUF_CAP];
 } BufferMapResult;
 
 typedef struct {
     uint32_t status;
     uint32_t done;
+    char message[DOE_ERROR_BUF_CAP];
 } QueueWorkDoneResult;
 
 static void buffer_map_callback(uint32_t status, WGPUStringView message,
     void* userdata1, void* userdata2) {
-    (void)message; (void)userdata2;
+    (void)userdata2;
     BufferMapResult* r = (BufferMapResult*)userdata1;
     r->status = status;
+    copy_string_view_message(message, r->message, sizeof(r->message));
     r->done = 1;
 }
 
 static void queue_work_done_callback(uint32_t status, WGPUStringView message,
     void* userdata1, void* userdata2) {
-    (void)message; (void)userdata2;
+    (void)userdata2;
     QueueWorkDoneResult* r = (QueueWorkDoneResult*)userdata1;
     r->status = status;
+    copy_string_view_message(message, r->message, sizeof(r->message));
     r->done = 1;
 }
 
@@ -853,13 +1124,14 @@ static napi_value doe_buffer_map_sync(napi_env env, napi_callback_info info) {
     CHECK_LIB_LOADED(env);
     WGPUInstance inst = unwrap_ptr(env, _args[0]);
     WGPUBuffer buf = unwrap_ptr(env, _args[1]);
+    if (!inst || !buf) NAPI_THROW(env, "bufferMapSync requires instance and buffer");
     uint32_t mode;
     napi_get_value_uint32(env, _args[2], &mode);
     int64_t offset_i, size_i;
     napi_get_value_int64(env, _args[3], &offset_i);
     napi_get_value_int64(env, _args[4], &size_i);
 
-    BufferMapResult result = {0, 0};
+    BufferMapResult result = {0};
     WGPUBufferMapCallbackInfo cb_info = {
         .nextInChain = NULL,
         .mode = WGPU_CALLBACK_MODE_ALLOW_PROCESS_EVENTS,
@@ -871,9 +1143,10 @@ static napi_value doe_buffer_map_sync(napi_env env, napi_callback_info info) {
     WGPUFuture future = pfn_wgpuBufferMapAsync2(buf, (uint64_t)mode,
         (size_t)offset_i, (size_t)size_i, cb_info);
     if (future.id == 0) NAPI_THROW(env, "bufferMapAsync future unavailable");
-    if (!process_events_until(inst, &result.done, DOE_DEFAULT_TIMEOUT_NS) ||
-        result.status != WGPU_MAP_ASYNC_STATUS_SUCCESS)
-        NAPI_THROW(env, "bufferMapAsync failed");
+    if (!process_events_until(inst, &result.done, current_timeout_ns()))
+        return throw_status_error(env, "DOE_BUFFER_MAP_TIMEOUT", "bufferMapAsync timed out", result.status, result.message);
+    if (result.status != WGPU_MAP_ASYNC_STATUS_SUCCESS)
+        return throw_status_error(env, "DOE_BUFFER_MAP_ERROR", "bufferMapAsync failed", result.status, result.message);
 
     napi_value ok;
     napi_get_boolean(env, true, &ok);
@@ -889,17 +1162,90 @@ static napi_value doe_buffer_get_mapped_range(napi_env env, napi_callback_info i
     napi_get_value_int64(env, _args[1], &offset_i);
     napi_get_value_int64(env, _args[2], &size_i);
 
-    const void* data = pfn_wgpuBufferGetConstMappedRange(buf, (size_t)offset_i, (size_t)size_i);
+    void* data = pfn_wgpuBufferGetMappedRange(buf, (size_t)offset_i, (size_t)size_i);
+    if (!data) {
+        data = (void*)pfn_wgpuBufferGetConstMappedRange(buf, (size_t)offset_i, (size_t)size_i);
+    }
     if (!data) NAPI_THROW(env, "getMappedRange returned NULL");
 
-    /* Copy native data into a JS ArrayBuffer */
-    void* ab_data = NULL;
     napi_value ab;
-    napi_create_arraybuffer(env, (size_t)size_i, &ab_data, &ab);
-    memcpy(ab_data, data, (size_t)size_i);
+    napi_create_external_arraybuffer(env, data, (size_t)size_i, NULL, NULL, &ab);
     return ab;
 }
 
+static napi_value doe_buffer_write_mapped_range(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 3);
+    CHECK_LIB_LOADED(env);
+    WGPUBuffer buf = unwrap_ptr(env, _args[0]);
+    int64_t offset_i = 0;
+    napi_get_value_int64(env, _args[1], &offset_i);
+
+    void* data = NULL;
+    size_t byte_length = 0;
+    bool is_typed_array = false;
+    napi_is_typedarray(env, _args[2], &is_typed_array);
+    if (is_typed_array) {
+        napi_typedarray_type ta_type;
+        size_t ta_length = 0;
+        void* ta_data = NULL;
+        napi_value ta_arraybuffer;
+        size_t ta_byte_offset = 0;
+        napi_get_typedarray_info(env, _args[2], &ta_type, &ta_length, &ta_data, &ta_arraybuffer, &ta_byte_offset);
+        data = ta_data;
+        switch (ta_type) {
+            case napi_uint16_array: case napi_int16_array: byte_length = ta_length * 2; break;
+            case napi_uint32_array: case napi_int32_array: case napi_float32_array: byte_length = ta_length * 4; break;
+            case napi_float64_array: case napi_bigint64_array: case napi_biguint64_array: byte_length = ta_length * 8; break;
+            default: byte_length = ta_length; break;
+        }
+    } else {
+        bool is_ab = false;
+        napi_is_arraybuffer(env, _args[2], &is_ab);
+        if (is_ab) {
+            napi_get_arraybuffer_info(env, _args[2], &data, &byte_length);
+        } else {
+            bool is_buffer = false;
+            napi_is_buffer(env, _args[2], &is_buffer);
+            if (is_buffer) {
+                napi_get_buffer_info(env, _args[2], &data, &byte_length);
+            } else {
+                NAPI_THROW(env, "bufferWriteMappedRange: data must be TypedArray, ArrayBuffer, or Buffer");
+            }
+        }
+    }
+
+    void* mapped = pfn_wgpuBufferGetMappedRange(buf, (size_t)offset_i, byte_length);
+    if (!mapped) NAPI_THROW(env, "bufferWriteMappedRange: mapped range unavailable");
+    memcpy(mapped, data, byte_length);
+    return NULL;
+}
+
+static napi_value doe_buffer_read_indirect_counts(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 2);
+    CHECK_LIB_LOADED(env);
+    WGPUBuffer buf = unwrap_ptr(env, _args[0]);
+    int64_t offset_i = 0;
+    napi_get_value_int64(env, _args[1], &offset_i);
+    if (!buf) NAPI_THROW(env, "bufferReadIndirectCounts requires buffer");
+    if (offset_i < 0) NAPI_THROW(env, "bufferReadIndirectCounts offset must be non-negative");
+
+    const uint32_t* counts = (const uint32_t*)pfn_wgpuBufferGetConstMappedRange(buf, (size_t)offset_i, 3 * sizeof(uint32_t));
+    if (!counts) NAPI_THROW(env, "bufferReadIndirectCounts: unable to read indirect data");
+
+    napi_value result;
+    napi_create_object(env, &result);
+    napi_value x;
+    napi_value y;
+    napi_value z;
+    napi_create_uint32(env, counts[0], &x);
+    napi_create_uint32(env, counts[1], &y);
+    napi_create_uint32(env, counts[2], &z);
+    napi_set_named_property(env, result, "x", x);
+    napi_set_named_property(env, result, "y", y);
+    napi_set_named_property(env, result, "z", z);
+    return result;
+}
+
 /* bufferAssertMappedPrefixF32(buffer, expected, count) */
 static napi_value doe_buffer_assert_mapped_prefix_f32(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 3);
@@ -951,10 +1297,100 @@ static napi_value doe_create_shader_module(napi_env env, napi_callback_info info
 
     WGPUShaderModule mod = pfn_wgpuDeviceCreateShaderModule(device, &desc);
     free(code);
-    if (!mod) NAPI_THROW(env, "createShaderModule failed (WGSL translation or compilation error — check stderr for details)");
+    if (!mod) {
+        char msg[DOE_ERROR_BUF_CAP];
+        char stage[64];
+        char kind[64];
+        copy_library_error_message(msg, sizeof(msg));
+        copy_library_error_meta(pfn_doeNativeCopyLastErrorStage, stage, sizeof(stage));
+        copy_library_error_meta(pfn_doeNativeCopyLastErrorKind, kind, sizeof(kind));
+        if (msg[0] != '\0') {
+            char full_msg[DOE_ERROR_BUF_CAP];
+            if (stage[0] != '\0' && kind[0] != '\0') {
+                snprintf(full_msg, sizeof(full_msg), "[%s/%s] %s", stage, kind, msg);
+            } else if (stage[0] != '\0') {
+                snprintf(full_msg, sizeof(full_msg), "[%s] %s", stage, msg);
+            } else {
+                snprintf(full_msg, sizeof(full_msg), "%s", msg);
+            }
+            napi_throw_error(env, "DOE_SHADER_MODULE_ERROR", full_msg);
+        } else {
+            napi_throw_error(env, "DOE_SHADER_MODULE_ERROR", "createShaderModule failed (WGSL translation or compilation error)");
+        }
+        return NULL;
+    }
     return wrap_ptr(env, mod);
 }
 
+static napi_value doe_check_shader_source(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 1);
+    CHECK_LIB_LOADED(env);
+    napi_valuetype value_type;
+    if (napi_typeof(env, _args[0], &value_type) != napi_ok || value_type != napi_string) {
+        NAPI_THROW(env, "checkShaderSource requires a WGSL source string");
+    }
+    napi_value result;
+    napi_create_object(env, &result);
+    if (!pfn_doeNativeCheckShaderSource) {
+        napi_value ok;
+        napi_get_boolean(env, true, &ok);
+        napi_set_named_property(env, result, "ok", ok);
+        return result;
+    }
+
+    size_t code_len = 0;
+    napi_get_value_string_utf8(env, _args[0], NULL, 0, &code_len);
+    char* code = (char*)malloc(code_len + 1);
+    if (!code) NAPI_THROW(env, "checkShaderSource: out of memory");
+    napi_get_value_string_utf8(env, _args[0], code, code_len + 1, &code_len);
+
+    const uint32_t ok_status = pfn_doeNativeCheckShaderSource(code, code_len);
+    free(code);
+
+    napi_value ok;
+    napi_get_boolean(env, ok_status != 0, &ok);
+    napi_set_named_property(env, result, "ok", ok);
+    if (ok_status != 0) return result;
+
+    char message[DOE_ERROR_BUF_CAP];
+    char stage[64];
+    char kind[64];
+    copy_library_error_message(message, sizeof(message));
+    copy_library_error_meta(pfn_doeNativeCopyLastErrorStage, stage, sizeof(stage));
+    copy_library_error_meta(pfn_doeNativeCopyLastErrorKind, kind, sizeof(kind));
+
+    napi_value message_val;
+    napi_create_string_utf8(env, message, NAPI_AUTO_LENGTH, &message_val);
+    napi_set_named_property(env, result, "message", message_val);
+    if (stage[0] != '\0') {
+        napi_value stage_val;
+        napi_create_string_utf8(env, stage, NAPI_AUTO_LENGTH, &stage_val);
+        napi_set_named_property(env, result, "stage", stage_val);
+    }
+    if (kind[0] != '\0') {
+        napi_value kind_val;
+        napi_create_string_utf8(env, kind, NAPI_AUTO_LENGTH, &kind_val);
+        napi_set_named_property(env, result, "kind", kind_val);
+    }
+    if (pfn_doeNativeGetLastErrorLine) {
+        uint32_t line = pfn_doeNativeGetLastErrorLine();
+        if (line > 0) {
+            napi_value line_val;
+            napi_create_uint32(env, line, &line_val);
+            napi_set_named_property(env, result, "line", line_val);
+        }
+    }
+    if (pfn_doeNativeGetLastErrorColumn) {
+        uint32_t col = pfn_doeNativeGetLastErrorColumn();
+        if (col > 0) {
+            napi_value col_val;
+            napi_create_uint32(env, col, &col_val);
+            napi_set_named_property(env, result, "column", col_val);
+        }
+    }
+    return result;
+}
+
 static napi_value doe_shader_module_release(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 1);
     void* mod = unwrap_ptr(env, _args[0]);
@@ -962,6 +1398,70 @@ static napi_value doe_shader_module_release(napi_env env, napi_callback_info inf
     return NULL;
 }
 
+static const char* doe_binding_kind_name(uint32_t kind) {
+    switch (kind) {
+        case 0: return "buffer";
+        case 1: return "sampler";
+        case 2: return "texture";
+        case 3: return "storage_texture";
+        default: return "unknown";
+    }
+}
+
+static const char* doe_binding_space_name(uint32_t addr_space) {
+    switch (addr_space) {
+        case 0: return "function";
+        case 1: return "private";
+        case 2: return "workgroup";
+        case 3: return "uniform";
+        case 4: return "storage";
+        case 5: return "handle";
+        default: return "unknown";
+    }
+}
+
+static const char* doe_binding_access_name(uint32_t access) {
+    switch (access) {
+        case 0: return "read";
+        case 1: return "write";
+        case 2: return "read_write";
+        default: return "unknown";
+    }
+}
+
+static napi_value doe_shader_module_get_bindings(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 1);
+    WGPUShaderModule shader_module = unwrap_ptr(env, _args[0]);
+    if (!shader_module) NAPI_THROW(env, "shaderModuleGetBindings: null shader module");
+    if (!pfn_doeNativeShaderModuleGetBindings) NAPI_THROW(env, "shaderModuleGetBindings: native binding metadata not available");
+
+    DoeShaderBindingInfo bindings[16];
+    size_t count = pfn_doeNativeShaderModuleGetBindings(shader_module, bindings, 16);
+
+    napi_value array;
+    napi_create_array_with_length(env, count, &array);
+    for (size_t i = 0; i < count; i++) {
+        napi_value entry;
+        napi_create_object(env, &entry);
+
+        napi_value group, binding, kind, space, access;
+        napi_create_uint32(env, bindings[i].group, &group);
+        napi_create_uint32(env, bindings[i].binding, &binding);
+        napi_create_string_utf8(env, doe_binding_kind_name(bindings[i].kind), NAPI_AUTO_LENGTH, &kind);
+        napi_create_string_utf8(env, doe_binding_space_name(bindings[i].addr_space), NAPI_AUTO_LENGTH, &space);
+        napi_create_string_utf8(env, doe_binding_access_name(bindings[i].access), NAPI_AUTO_LENGTH, &access);
+
+        napi_set_named_property(env, entry, "group", group);
+        napi_set_named_property(env, entry, "binding", binding);
+        napi_set_named_property(env, entry, "type", kind);
+        napi_set_named_property(env, entry, "space", space);
+        napi_set_named_property(env, entry, "access", access);
+        napi_set_element(env, array, i, entry);
+    }
+
+    return array;
+}
+
 /* ================================================================
  * Compute Pipeline
  * createComputePipeline(device, shaderModule, entryPoint, pipelineLayout?)
@@ -994,7 +1494,28 @@ static napi_value doe_create_compute_pipeline(napi_env env, napi_callback_info i
 
     WGPUComputePipeline pipeline = pfn_wgpuDeviceCreateComputePipeline(device, &desc);
     free(ep);
-    if (!pipeline) NAPI_THROW(env, "createComputePipeline failed (shader module invalid or entry point not found — check stderr for details)");
+    if (!pipeline) {
+        char msg[DOE_ERROR_BUF_CAP];
+        char stage[64];
+        char kind[64];
+        copy_library_error_message(msg, sizeof(msg));
+        copy_library_error_meta(pfn_doeNativeCopyLastErrorStage, stage, sizeof(stage));
+        copy_library_error_meta(pfn_doeNativeCopyLastErrorKind, kind, sizeof(kind));
+        if (msg[0] != '\0') {
+            char full_msg[DOE_ERROR_BUF_CAP];
+            if (stage[0] != '\0' && kind[0] != '\0') {
+                snprintf(full_msg, sizeof(full_msg), "[%s/%s] %s", stage, kind, msg);
+            } else if (stage[0] != '\0') {
+                snprintf(full_msg, sizeof(full_msg), "[%s] %s", stage, msg);
+            } else {
+                snprintf(full_msg, sizeof(full_msg), "%s", msg);
+            }
+            napi_throw_error(env, "DOE_COMPUTE_PIPELINE_ERROR", full_msg);
+        } else {
+            napi_throw_error(env, "DOE_COMPUTE_PIPELINE_ERROR", "createComputePipeline failed");
+        }
+        return NULL;
+    }
     return wrap_ptr(env, pipeline);
 }
 
@@ -1021,7 +1542,9 @@ static napi_value doe_compute_pipeline_get_bind_group_layout(napi_env env, napi_
 /* ================================================================
  * Bind Group Layout
  * createBindGroupLayout(device, entries[])
- * Each entry: { binding, visibility, buffer?: { type }, storageTexture?: { ... } }
+ * Each entry: { binding, visibility, buffer?: { type }, sampler?: { type },
+ *               texture?: { sampleType, viewDimension, multisampled },
+ *               storageTexture?: { access, format, viewDimension } }
  * ================================================================ */
 
 static uint32_t buffer_binding_type_from_string(napi_env env, napi_value val) {
@@ -1037,6 +1560,68 @@ static uint32_t buffer_binding_type_from_string(napi_env env, napi_value val) {
     return 0x00000001;
 }
 
+static uint32_t sampler_binding_type_from_string(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt != napi_string) return 0x00000001; /* Undefined */
+    char buf[32] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "filtering") == 0) return 0x00000002;
+    if (strcmp(buf, "non-filtering") == 0 || strcmp(buf, "non_filtering") == 0) return 0x00000003;
+    if (strcmp(buf, "comparison") == 0) return 0x00000004;
+    return 0x00000001;
+}
+
+static uint32_t texture_sample_type_from_string(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt != napi_string) return 0x00000001; /* Undefined */
+    char buf[64] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "float") == 0) return 0x00000002;
+    if (strcmp(buf, "unfilterable-float") == 0 || strcmp(buf, "unfilterable_float") == 0) return 0x00000003;
+    if (strcmp(buf, "depth") == 0) return 0x00000004;
+    if (strcmp(buf, "sint") == 0) return 0x00000005;
+    if (strcmp(buf, "uint") == 0) return 0x00000006;
+    return 0x00000001;
+}
+
+static uint32_t texture_view_dimension_from_string(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt != napi_string) return 0x00000000; /* Undefined */
+    char buf[32] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "1d") == 0) return 0x00000001;
+    if (strcmp(buf, "2d") == 0) return 0x00000002;
+    if (strcmp(buf, "2d-array") == 0 || strcmp(buf, "2d_array") == 0) return 0x00000003;
+    if (strcmp(buf, "cube") == 0) return 0x00000004;
+    if (strcmp(buf, "cube-array") == 0 || strcmp(buf, "cube_array") == 0) return 0x00000005;
+    if (strcmp(buf, "3d") == 0) return 0x00000006;
+    return 0x00000000;
+}
+
+static uint32_t storage_texture_access_from_string(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt != napi_string) return 0x00000001; /* Undefined */
+    char buf[32] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "write-only") == 0 || strcmp(buf, "write_only") == 0) return 0x00000002;
+    if (strcmp(buf, "read-only") == 0 || strcmp(buf, "read_only") == 0) return 0x00000003;
+    if (strcmp(buf, "read-write") == 0 || strcmp(buf, "read_write") == 0) return 0x00000004;
+    return 0x00000001;
+}
+
+static uint32_t texture_format_from_string(napi_env env, napi_value val);
+static uint32_t primitive_topology_from_string(napi_env env, napi_value val);
+static uint32_t front_face_from_string(napi_env env, napi_value val);
+static uint32_t cull_mode_from_string(napi_env env, napi_value val);
+
 static napi_value doe_create_bind_group_layout(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 2);
     CHECK_LIB_LOADED(env);
@@ -1066,11 +1651,27 @@ static napi_value doe_create_bind_group_layout(napi_env env, napi_callback_info
                 entries[i].buffer.minBindingSize = (uint64_t)get_int64_prop(env, buf_obj, "minBindingSize");
         }
 
+        if (has_prop(env, elem, "sampler") && prop_type(env, elem, "sampler") == napi_object) {
+            napi_value sampler_obj = get_prop(env, elem, "sampler");
+            entries[i].sampler.type = sampler_binding_type_from_string(
+                env, get_prop(env, sampler_obj, "type"));
+        }
+
+        if (has_prop(env, elem, "texture") && prop_type(env, elem, "texture") == napi_object) {
+            napi_value tex_obj = get_prop(env, elem, "texture");
+            entries[i].texture.sampleType = texture_sample_type_from_string(
+                env, get_prop(env, tex_obj, "sampleType"));
+            entries[i].texture.viewDimension = texture_view_dimension_from_string(
+                env, get_prop(env, tex_obj, "viewDimension"));
+            if (has_prop(env, tex_obj, "multisampled"))
+                entries[i].texture.multisampled = get_bool_prop(env, tex_obj, "multisampled") ? 1 : 0;
+        }
+
         if (has_prop(env, elem, "storageTexture") && prop_type(env, elem, "storageTexture") == napi_object) {
             napi_value st_obj = get_prop(env, elem, "storageTexture");
-            entries[i].storageTexture.access = get_uint32_prop(env, st_obj, "access");
-            entries[i].storageTexture.format = get_uint32_prop(env, st_obj, "format");
-            entries[i].storageTexture.viewDimension = get_uint32_prop(env, st_obj, "viewDimension");
+            entries[i].storageTexture.access = storage_texture_access_from_string(env, get_prop(env, st_obj, "access"));
+            entries[i].storageTexture.format = texture_format_from_string(env, get_prop(env, st_obj, "format"));
+            entries[i].storageTexture.viewDimension = texture_view_dimension_from_string(env, get_prop(env, st_obj, "viewDimension"));
         }
     }
 
@@ -1097,7 +1698,7 @@ static napi_value doe_bind_group_layout_release(napi_env env, napi_callback_info
 /* ================================================================
  * Bind Group
  * createBindGroup(device, layout, entries[])
- * Each entry: { binding, buffer, offset?, size? }
+ * Each entry: { binding, buffer?, offset?, size?, sampler?, textureView? }
  * ================================================================ */
 
 static napi_value doe_create_bind_group(napi_env env, napi_callback_info info) {
@@ -1122,6 +1723,12 @@ static napi_value doe_create_bind_group(napi_env env, napi_callback_info info) {
         if (has_prop(env, elem, "buffer") && prop_type(env, elem, "buffer") == napi_external)
             entries[i].buffer = unwrap_ptr(env, get_prop(env, elem, "buffer"));
 
+        if (has_prop(env, elem, "sampler") && prop_type(env, elem, "sampler") == napi_external)
+            entries[i].sampler = unwrap_ptr(env, get_prop(env, elem, "sampler"));
+
+        if (has_prop(env, elem, "textureView") && prop_type(env, elem, "textureView") == napi_external)
+            entries[i].textureView = unwrap_ptr(env, get_prop(env, elem, "textureView"));
+
         if (has_prop(env, elem, "offset"))
             entries[i].offset = (uint64_t)get_int64_prop(env, elem, "offset");
 
@@ -1235,6 +1842,56 @@ static napi_value doe_command_encoder_copy_buffer_to_buffer(napi_env env, napi_c
     return NULL;
 }
 
+static napi_value doe_command_encoder_copy_texture_to_buffer(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 14);
+    CHECK_LIB_LOADED(env);
+    WGPUCommandEncoder enc = unwrap_ptr(env, _args[0]);
+    WGPUTexture src_texture = unwrap_ptr(env, _args[1]);
+    if (!enc || !src_texture) NAPI_THROW(env, "commandEncoderCopyTextureToBuffer requires encoder and texture");
+
+    WGPUTexelCopyTextureInfo src;
+    memset(&src, 0, sizeof(src));
+    src.texture = src_texture;
+    napi_get_value_uint32(env, _args[2], &src.mipLevel);
+    napi_get_value_uint32(env, _args[3], &src.origin.x);
+    napi_get_value_uint32(env, _args[4], &src.origin.y);
+    napi_get_value_uint32(env, _args[5], &src.origin.z);
+    napi_get_value_uint32(env, _args[6], &src.aspect);
+
+    WGPUTexelCopyBufferInfo dst;
+    memset(&dst, 0, sizeof(dst));
+    dst.buffer = unwrap_ptr(env, _args[7]);
+    if (!dst.buffer) NAPI_THROW(env, "commandEncoderCopyTextureToBuffer requires destination buffer");
+    int64_t dst_offset = 0;
+    napi_get_value_int64(env, _args[8], &dst_offset);
+    dst.layout.offset = (uint64_t)dst_offset;
+    napi_get_value_uint32(env, _args[9], &dst.layout.bytesPerRow);
+    napi_get_value_uint32(env, _args[10], &dst.layout.rowsPerImage);
+
+    WGPUExtent3D size;
+    napi_get_value_uint32(env, _args[11], &size.width);
+    napi_get_value_uint32(env, _args[12], &size.height);
+    napi_get_value_uint32(env, _args[13], &size.depthOrArrayLayers);
+
+    if (pfn_doeNativeCommandEncoderCopyTextureToBuffer) {
+        pfn_doeNativeCommandEncoderCopyTextureToBuffer(
+            enc,
+            src.texture,
+            src.mipLevel,
+            dst.buffer,
+            dst.layout.offset,
+            dst.layout.bytesPerRow,
+            dst.layout.rowsPerImage,
+            size.width,
+            size.height,
+            size.depthOrArrayLayers
+        );
+    } else {
+        pfn_wgpuCommandEncoderCopyTextureToBuffer(enc, &src, &dst, &size);
+    }
+    return NULL;
+}
+
 static napi_value doe_command_encoder_finish(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 1);
     CHECK_LIB_LOADED(env);
@@ -1360,6 +2017,7 @@ static napi_value doe_queue_write_buffer(napi_env env, napi_callback_info info)
     CHECK_LIB_LOADED(env);
     WGPUQueue queue = unwrap_ptr(env, _args[0]);
     WGPUBuffer buf = unwrap_ptr(env, _args[1]);
+    if (!queue || !buf) NAPI_THROW(env, "queueWriteBuffer requires queue and buffer");
     int64_t offset; napi_get_value_int64(env, _args[2], &offset);
 
     void* data = NULL;
@@ -1415,9 +2073,12 @@ static napi_value doe_queue_flush(napi_env env, napi_callback_info info) {
         pfn_doeNativeQueueFlush(queue);
         return NULL;
     }
-    if (!inst) NAPI_THROW(env, "queueFlush requires instance when doeNativeQueueFlush is unavailable");
+    if (!inst) {
+        napi_throw_error(env, "DOE_QUEUE_UNAVAILABLE", "queueFlush requires instance when doeNativeQueueFlush is unavailable");
+        return NULL;
+    }
 
-    QueueWorkDoneResult result = {0, 0};
+    QueueWorkDoneResult result = {0};
     WGPUQueueWorkDoneCallbackInfo cb_info = {
         .nextInChain = NULL,
         .mode = WGPU_CALLBACK_MODE_WAIT_ANY_ONLY,
@@ -1441,19 +2102,20 @@ static napi_value doe_queue_flush(napi_env env, napi_callback_info info) {
             }
         } else if (wait_status == WGPU_WAIT_STATUS_TIMED_OUT) {
             pfn_wgpuInstanceProcessEvents(inst);
-            if (monotonic_now_ns() - start_ns >= DOE_DEFAULT_TIMEOUT_NS) {
-                NAPI_THROW(env, "queueFlush: queue wait timed out");
+            if (monotonic_now_ns() - start_ns >= current_timeout_ns()) {
+                napi_throw_error(env, "DOE_QUEUE_TIMEOUT", "queueFlush: queue wait timed out");
+                return NULL;
             }
             wait_slice();
         } else if (wait_status == WGPU_WAIT_STATUS_ERROR) {
-            NAPI_THROW(env, "queueFlush: wgpuInstanceWaitAny failed");
+            napi_throw_error(env, "DOE_QUEUE_UNAVAILABLE", "queueFlush: wgpuInstanceWaitAny failed");
+            return NULL;
         } else {
             NAPI_THROW(env, "queueFlush: unsupported wait status");
         }
     }
-    if (result.status != WGPU_QUEUE_WORK_DONE_STATUS_SUCCESS) {
-        NAPI_THROW(env, "queueFlush: queue work did not complete");
-    }
+    if (result.status != WGPU_QUEUE_WORK_DONE_STATUS_SUCCESS)
+        return throw_status_error(env, "DOE_QUEUE_FLUSH_ERROR", "queueFlush: queue work did not complete", result.status, result.message);
     return NULL;
 }
 
@@ -1677,7 +2339,7 @@ static napi_value doe_flush_and_map_sync(napi_env env, napi_callback_info info)
     }
 
     /* Map the buffer synchronously via processEvents polling. */
-    BufferMapResult result = {0, 0};
+    BufferMapResult result = {0};
     WGPUBufferMapCallbackInfo cb_info = {
         .nextInChain = NULL,
         .mode = WGPU_CALLBACK_MODE_ALLOW_PROCESS_EVENTS,
@@ -1688,9 +2350,10 @@ static napi_value doe_flush_and_map_sync(napi_env env, napi_callback_info info)
     WGPUFuture future = pfn_wgpuBufferMapAsync2(buf, (uint64_t)mode,
         (size_t)offset_i, (size_t)size_i, cb_info);
     if (future.id == 0) NAPI_THROW(env, "flushAndMapSync: bufferMapAsync future unavailable");
-    if (!process_events_until(inst, &result.done, DOE_DEFAULT_TIMEOUT_NS) ||
-        result.status != WGPU_MAP_ASYNC_STATUS_SUCCESS)
-        NAPI_THROW(env, "flushAndMapSync: bufferMapAsync failed");
+    if (!process_events_until(inst, &result.done, current_timeout_ns()))
+        return throw_status_error(env, "DOE_BUFFER_MAP_TIMEOUT", "flushAndMapSync: bufferMapAsync timed out", result.status, result.message);
+    if (result.status != WGPU_MAP_ASYNC_STATUS_SUCCESS)
+        return throw_status_error(env, "DOE_BUFFER_MAP_ERROR", "flushAndMapSync: bufferMapAsync failed", result.status, result.message);
 
     napi_value ok;
     napi_get_boolean(env, true, &ok);
@@ -1722,14 +2385,246 @@ static uint32_t texture_format_from_string(napi_env env, napi_value val) {
     char buf[32] = {0};
     size_t len = 0;
     napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
-    if (strcmp(buf, "rgba8unorm") == 0)      return 0x00000016;
-    if (strcmp(buf, "rgba8unorm-srgb") == 0) return 0x00000017;
-    if (strcmp(buf, "bgra8unorm") == 0)      return 0x0000001B;
-    if (strcmp(buf, "bgra8unorm-srgb") == 0) return 0x0000001C;
-    if (strcmp(buf, "depth32float") == 0)    return 0x00000030;
+    if (strcmp(buf, "r8unorm") == 0)          return 0x00000001;
+    if (strcmp(buf, "r8snorm") == 0)          return 0x00000002;
+    if (strcmp(buf, "r8uint") == 0)           return 0x00000003;
+    if (strcmp(buf, "r8sint") == 0)           return 0x00000004;
+    if (strcmp(buf, "r16uint") == 0)          return 0x00000007;
+    if (strcmp(buf, "r16sint") == 0)          return 0x00000008;
+    if (strcmp(buf, "r16float") == 0)         return 0x00000009;
+    if (strcmp(buf, "rg8unorm") == 0)         return 0x0000000A;
+    if (strcmp(buf, "rg8snorm") == 0)         return 0x0000000B;
+    if (strcmp(buf, "rg8uint") == 0)          return 0x0000000C;
+    if (strcmp(buf, "rg8sint") == 0)          return 0x0000000D;
+    if (strcmp(buf, "r32float") == 0)         return 0x0000000E;
+    if (strcmp(buf, "r32uint") == 0)          return 0x0000000F;
+    if (strcmp(buf, "r32sint") == 0)          return 0x00000010;
+    if (strcmp(buf, "rg16uint") == 0)         return 0x00000013;
+    if (strcmp(buf, "rg16sint") == 0)         return 0x00000014;
+    if (strcmp(buf, "rg16float") == 0)        return 0x00000015;
+    if (strcmp(buf, "rgba8unorm") == 0)       return 0x00000016;
+    if (strcmp(buf, "rgba8unorm-srgb") == 0)  return 0x00000017;
+    if (strcmp(buf, "rgba8snorm") == 0)       return 0x00000018;
+    if (strcmp(buf, "rgba8uint") == 0)        return 0x00000019;
+    if (strcmp(buf, "rgba8sint") == 0)        return 0x0000001A;
+    if (strcmp(buf, "bgra8unorm") == 0)       return 0x0000001B;
+    if (strcmp(buf, "bgra8unorm-srgb") == 0)  return 0x0000001C;
+    if (strcmp(buf, "rgb10a2uint") == 0)      return 0x0000001D;
+    if (strcmp(buf, "rgb10a2unorm") == 0)     return 0x0000001E;
+    if (strcmp(buf, "rg11b10ufloat") == 0)    return 0x0000001F;
+    if (strcmp(buf, "rgb9e5ufloat") == 0)     return 0x00000020;
+    if (strcmp(buf, "rg32float") == 0)        return 0x00000021;
+    if (strcmp(buf, "rg32uint") == 0)         return 0x00000022;
+    if (strcmp(buf, "rg32sint") == 0)         return 0x00000023;
+    if (strcmp(buf, "rgba16uint") == 0)       return 0x00000024;
+    if (strcmp(buf, "rgba16sint") == 0)       return 0x00000025;
+    if (strcmp(buf, "rgba16float") == 0)      return 0x00000026;
+    if (strcmp(buf, "rgba32float") == 0)      return 0x00000027;
+    if (strcmp(buf, "rgba32uint") == 0)       return 0x00000028;
+    if (strcmp(buf, "rgba32sint") == 0)       return 0x00000029;
+    if (strcmp(buf, "stencil8") == 0)         return 0x0000002C;
+    if (strcmp(buf, "depth16unorm") == 0)     return 0x0000002D;
+    if (strcmp(buf, "depth24plus") == 0)      return 0x0000002E;
+    if (strcmp(buf, "depth24plus-stencil8") == 0) return 0x0000002F;
+    if (strcmp(buf, "depth32float") == 0)     return 0x00000030;
+    if (strcmp(buf, "depth32float-stencil8") == 0) return 0x00000031;
+    /* BC compressed formats */
+    if (strcmp(buf, "bc1-rgba-unorm") == 0)      return 0x00000032;
+    if (strcmp(buf, "bc1-rgba-unorm-srgb") == 0) return 0x00000033;
+    if (strcmp(buf, "bc2-rgba-unorm") == 0)      return 0x00000034;
+    if (strcmp(buf, "bc2-rgba-unorm-srgb") == 0) return 0x00000035;
+    if (strcmp(buf, "bc3-rgba-unorm") == 0)      return 0x00000036;
+    if (strcmp(buf, "bc3-rgba-unorm-srgb") == 0) return 0x00000037;
+    if (strcmp(buf, "bc4-r-unorm") == 0)         return 0x00000038;
+    if (strcmp(buf, "bc4-r-snorm") == 0)         return 0x00000039;
+    if (strcmp(buf, "bc5-rg-unorm") == 0)        return 0x0000003A;
+    if (strcmp(buf, "bc5-rg-snorm") == 0)        return 0x0000003B;
+    if (strcmp(buf, "bc6h-rgb-ufloat") == 0)     return 0x0000003C;
+    if (strcmp(buf, "bc6h-rgb-float") == 0)      return 0x0000003D;
+    if (strcmp(buf, "bc7-rgba-unorm") == 0)      return 0x0000003E;
+    if (strcmp(buf, "bc7-rgba-unorm-srgb") == 0) return 0x0000003F;
+    /* ETC2/EAC compressed formats */
+    if (strcmp(buf, "etc2-rgb8unorm") == 0)       return 0x00000040;
+    if (strcmp(buf, "etc2-rgb8unorm-srgb") == 0)  return 0x00000041;
+    if (strcmp(buf, "etc2-rgb8a1unorm") == 0)     return 0x00000042;
+    if (strcmp(buf, "etc2-rgb8a1unorm-srgb") == 0) return 0x00000043;
+    if (strcmp(buf, "etc2-rgba8unorm") == 0)      return 0x00000044;
+    if (strcmp(buf, "etc2-rgba8unorm-srgb") == 0) return 0x00000045;
+    if (strcmp(buf, "eac-r11unorm") == 0)         return 0x00000046;
+    if (strcmp(buf, "eac-r11snorm") == 0)         return 0x00000047;
+    if (strcmp(buf, "eac-rg11unorm") == 0)        return 0x00000048;
+    if (strcmp(buf, "eac-rg11snorm") == 0)        return 0x00000049;
+    /* ASTC compressed formats */
+    if (strcmp(buf, "astc-4x4-unorm") == 0)       return 0x0000004A;
+    if (strcmp(buf, "astc-4x4-unorm-srgb") == 0)  return 0x0000004B;
+    if (strcmp(buf, "astc-5x4-unorm") == 0)       return 0x0000004C;
+    if (strcmp(buf, "astc-5x4-unorm-srgb") == 0)  return 0x0000004D;
+    if (strcmp(buf, "astc-5x5-unorm") == 0)       return 0x0000004E;
+    if (strcmp(buf, "astc-5x5-unorm-srgb") == 0)  return 0x0000004F;
+    if (strcmp(buf, "astc-6x5-unorm") == 0)       return 0x00000050;
+    if (strcmp(buf, "astc-6x5-unorm-srgb") == 0)  return 0x00000051;
+    if (strcmp(buf, "astc-6x6-unorm") == 0)       return 0x00000052;
+    if (strcmp(buf, "astc-6x6-unorm-srgb") == 0)  return 0x00000053;
+    if (strcmp(buf, "astc-8x5-unorm") == 0)       return 0x00000054;
+    if (strcmp(buf, "astc-8x5-unorm-srgb") == 0)  return 0x00000055;
+    if (strcmp(buf, "astc-8x6-unorm") == 0)       return 0x00000056;
+    if (strcmp(buf, "astc-8x6-unorm-srgb") == 0)  return 0x00000057;
+    if (strcmp(buf, "astc-8x8-unorm") == 0)       return 0x00000058;
+    if (strcmp(buf, "astc-8x8-unorm-srgb") == 0)  return 0x00000059;
+    if (strcmp(buf, "astc-10x5-unorm") == 0)      return 0x0000005A;
+    if (strcmp(buf, "astc-10x5-unorm-srgb") == 0) return 0x0000005B;
+    if (strcmp(buf, "astc-10x6-unorm") == 0)      return 0x0000005C;
+    if (strcmp(buf, "astc-10x6-unorm-srgb") == 0) return 0x0000005D;
+    if (strcmp(buf, "astc-10x8-unorm") == 0)      return 0x0000005E;
+    if (strcmp(buf, "astc-10x8-unorm-srgb") == 0) return 0x0000005F;
+    if (strcmp(buf, "astc-10x10-unorm") == 0)     return 0x00000060;
+    if (strcmp(buf, "astc-10x10-unorm-srgb") == 0) return 0x00000061;
+    if (strcmp(buf, "astc-12x10-unorm") == 0)     return 0x00000062;
+    if (strcmp(buf, "astc-12x10-unorm-srgb") == 0) return 0x00000063;
+    if (strcmp(buf, "astc-12x12-unorm") == 0)     return 0x00000064;
+    if (strcmp(buf, "astc-12x12-unorm-srgb") == 0) return 0x00000065;
     return 0x00000016;
 }
 
+static uint32_t primitive_topology_from_string(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt == napi_number) {
+        uint32_t out = 0;
+        napi_get_value_uint32(env, val, &out);
+        return out;
+    }
+    char buf[32] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "point-list") == 0) return 0x00000001;
+    if (strcmp(buf, "line-list") == 0) return 0x00000002;
+    if (strcmp(buf, "line-strip") == 0) return 0x00000003;
+    if (strcmp(buf, "triangle-list") == 0) return 0x00000004;
+    if (strcmp(buf, "triangle-strip") == 0) return 0x00000005;
+    napi_throw_error(env, "DOE_ERROR", "Unsupported primitive topology");
+    return 0;
+}
+
+static uint32_t front_face_from_string(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt == napi_number) {
+        uint32_t out = 0;
+        napi_get_value_uint32(env, val, &out);
+        return out;
+    }
+    char buf[16] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "ccw") == 0) return 0x00000001;
+    if (strcmp(buf, "cw") == 0) return 0x00000002;
+    napi_throw_error(env, "DOE_ERROR", "Unsupported frontFace");
+    return 0;
+}
+
+static uint32_t cull_mode_from_string(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt == napi_number) {
+        uint32_t out = 0;
+        napi_get_value_uint32(env, val, &out);
+        return out;
+    }
+    char buf[16] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "none") == 0) return 0x00000001;
+    if (strcmp(buf, "front") == 0) return 0x00000002;
+    if (strcmp(buf, "back") == 0) return 0x00000003;
+    napi_throw_error(env, "DOE_ERROR", "Unsupported cullMode");
+    return 0;
+}
+
+static uint32_t compare_func_from_value(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt == napi_number) {
+        uint32_t out = 0;
+        napi_get_value_uint32(env, val, &out);
+        return out;
+    }
+    char buf[24] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "never") == 0) return 0x00000001;
+    if (strcmp(buf, "less") == 0) return 0x00000002;
+    if (strcmp(buf, "equal") == 0) return 0x00000003;
+    if (strcmp(buf, "less-equal") == 0) return 0x00000004;
+    if (strcmp(buf, "greater") == 0) return 0x00000005;
+    if (strcmp(buf, "not-equal") == 0) return 0x00000006;
+    if (strcmp(buf, "greater-equal") == 0) return 0x00000007;
+    if (strcmp(buf, "always") == 0) return 0x00000008;
+    napi_throw_error(env, "DOE_ERROR", "Unsupported compare function");
+    return 0;
+}
+
+static uint32_t vertex_step_mode_from_value(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt == napi_number) {
+        uint32_t out = 0;
+        napi_get_value_uint32(env, val, &out);
+        return out;
+    }
+    char buf[24] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "vertex") == 0) return 0x00000001;
+    if (strcmp(buf, "instance") == 0) return 0x00000002;
+    napi_throw_error(env, "DOE_ERROR", "Unsupported vertex stepMode");
+    return 0;
+}
+
+static uint32_t vertex_format_from_value(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt == napi_number) {
+        uint32_t out = 0;
+        napi_get_value_uint32(env, val, &out);
+        return out;
+    }
+    char buf[32] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "float32") == 0) return 0x00000019;
+    if (strcmp(buf, "float32x2") == 0) return 0x0000001A;
+    if (strcmp(buf, "float32x3") == 0) return 0x0000001B;
+    if (strcmp(buf, "float32x4") == 0) return 0x0000001C;
+    if (strcmp(buf, "uint32") == 0) return 0x00000021;
+    if (strcmp(buf, "uint32x2") == 0) return 0x00000022;
+    if (strcmp(buf, "uint32x3") == 0) return 0x00000023;
+    if (strcmp(buf, "uint32x4") == 0) return 0x00000024;
+    if (strcmp(buf, "sint32") == 0) return 0x00000025;
+    if (strcmp(buf, "sint32x2") == 0) return 0x00000026;
+    if (strcmp(buf, "sint32x3") == 0) return 0x00000027;
+    if (strcmp(buf, "sint32x4") == 0) return 0x00000028;
+    napi_throw_error(env, "DOE_ERROR", "Unsupported vertex format");
+    return 0;
+}
+
+static uint32_t index_format_from_value(napi_env env, napi_value val) {
+    napi_valuetype vt;
+    napi_typeof(env, val, &vt);
+    if (vt == napi_number) {
+        uint32_t out = 0;
+        napi_get_value_uint32(env, val, &out);
+        return out;
+    }
+    char buf[16] = {0};
+    size_t len = 0;
+    napi_get_value_string_utf8(env, val, buf, sizeof(buf), &len);
+    if (strcmp(buf, "uint16") == 0) return 0x00000001;
+    if (strcmp(buf, "uint32") == 0) return 0x00000002;
+    napi_throw_error(env, "DOE_ERROR", "Unsupported index format");
+    return 0;
+}
+
 static napi_value doe_create_texture(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 2);
     CHECK_LIB_LOADED(env);
@@ -1749,7 +2644,9 @@ static napi_value doe_create_texture(napi_env env, napi_callback_info info) {
     if (has_prop(env, _args[1], "mipLevelCount"))
         desc.mipLevelCount = get_uint32_prop(env, _args[1], "mipLevelCount");
     desc.sampleCount = 1;
-    desc.dimension = 1; /* 2D */
+    desc.dimension = 2; /* WGPUTextureDimension_2D */
+    if (has_prop(env, _args[1], "dimension"))
+        desc.dimension = get_uint32_prop(env, _args[1], "dimension");
 
     WGPUTexture tex = pfn_wgpuDeviceCreateTexture(device, &desc);
     if (!tex) NAPI_THROW(env, "createTexture failed");
@@ -1853,16 +2750,246 @@ static napi_value doe_sampler_release(napi_env env, napi_callback_info info) {
 }
 
 /* ================================================================
- * Render Pipeline (noop stub — uses built-in Metal shaders)
- * createRenderPipeline(device)
+ * Render Pipeline
+ * createRenderPipeline(device, descriptor)
  * ================================================================ */
 
 static napi_value doe_create_render_pipeline(napi_env env, napi_callback_info info) {
-    NAPI_ASSERT_ARGC(env, info, 1);
+    NAPI_ASSERT_ARGC(env, info, 2);
     CHECK_LIB_LOADED(env);
     WGPUDevice device = unwrap_ptr(env, _args[0]);
     if (!device) NAPI_THROW(env, "Invalid device");
-    WGPURenderPipeline rp = pfn_wgpuDeviceCreateRenderPipeline(device, NULL);
+    napi_valuetype descriptor_type;
+    napi_typeof(env, _args[1], &descriptor_type);
+    if (descriptor_type != napi_object) NAPI_THROW(env, "createRenderPipeline requires a descriptor object");
+
+    if (prop_type(env, _args[1], "vertex") != napi_object) {
+        NAPI_THROW(env, "createRenderPipeline requires descriptor.vertex");
+    }
+    if (prop_type(env, _args[1], "fragment") != napi_object) {
+        NAPI_THROW(env, "createRenderPipeline requires descriptor.fragment");
+    }
+
+    napi_value vertex = get_prop(env, _args[1], "vertex");
+    napi_value fragment = get_prop(env, _args[1], "fragment");
+
+    napi_value targets = get_prop(env, fragment, "targets");
+    bool is_targets_array = false;
+    napi_is_array(env, targets, &is_targets_array);
+    if (!is_targets_array) NAPI_THROW(env, "createRenderPipeline requires descriptor.fragment.targets");
+    uint32_t target_count = 0;
+    napi_get_array_length(env, targets, &target_count);
+    if (target_count == 0) NAPI_THROW(env, "createRenderPipeline requires at least one fragment target");
+    if (target_count > 1) NAPI_THROW(env, "createRenderPipeline currently supports one color target on this package surface");
+
+    napi_value vertex_module_value = get_prop(env, vertex, "module");
+    WGPUShaderModule vertex_module = unwrap_ptr(env, vertex_module_value);
+    if (!vertex_module) NAPI_THROW(env, "createRenderPipeline: descriptor.vertex.module must be a shader module");
+    napi_value fragment_module_value = get_prop(env, fragment, "module");
+    WGPUShaderModule fragment_module = unwrap_ptr(env, fragment_module_value);
+    if (!fragment_module) NAPI_THROW(env, "createRenderPipeline: descriptor.fragment.module must be a shader module");
+
+    size_t vertex_entry_len = 0;
+    size_t fragment_entry_len = 0;
+    char* vertex_entry = has_prop(env, vertex, "entryPoint")
+        ? dup_string_value(env, get_prop(env, vertex, "entryPoint"), &vertex_entry_len)
+        : strdup("main");
+    if (!has_prop(env, vertex, "entryPoint")) vertex_entry_len = 4;
+    char* fragment_entry = has_prop(env, fragment, "entryPoint")
+        ? dup_string_value(env, get_prop(env, fragment, "entryPoint"), &fragment_entry_len)
+        : strdup("main");
+    if (!has_prop(env, fragment, "entryPoint")) fragment_entry_len = 4;
+    if (!vertex_entry || !fragment_entry) {
+        free(vertex_entry);
+        free(fragment_entry);
+        NAPI_THROW(env, "createRenderPipeline: out of memory");
+    }
+
+    WGPURenderVertexBufferLayout* vertex_buffers = NULL;
+    WGPURenderVertexAttribute* vertex_attributes = NULL;
+    WGPURenderDepthStencilState* depth_stencil = NULL;
+    uint32_t vertex_buffer_count = 0;
+
+    if (has_prop(env, vertex, "buffers")) {
+        napi_value buffers = get_prop(env, vertex, "buffers");
+        bool is_array = false;
+        napi_is_array(env, buffers, &is_array);
+        if (!is_array) {
+            free(vertex_entry);
+            free(fragment_entry);
+            NAPI_THROW(env, "createRenderPipeline: descriptor.vertex.buffers must be an array");
+        }
+        napi_get_array_length(env, buffers, &vertex_buffer_count);
+        if (vertex_buffer_count > 0) {
+            size_t total_attributes = 0;
+            for (uint32_t i = 0; i < vertex_buffer_count; i++) {
+                napi_value buffer_desc;
+                napi_get_element(env, buffers, i, &buffer_desc);
+                if (prop_type(env, buffer_desc, "attributes") == napi_object) {
+                    napi_value attrs = get_prop(env, buffer_desc, "attributes");
+                    bool attrs_is_array = false;
+                    napi_is_array(env, attrs, &attrs_is_array);
+                    if (!attrs_is_array) {
+                        free(vertex_entry);
+                        free(fragment_entry);
+                        NAPI_THROW(env, "createRenderPipeline: descriptor.vertex.buffers[*].attributes must be an array");
+                    }
+                    uint32_t attr_count = 0;
+                    napi_get_array_length(env, attrs, &attr_count);
+                    total_attributes += attr_count;
+                }
+            }
+
+            vertex_buffers = (WGPURenderVertexBufferLayout*)calloc(vertex_buffer_count, sizeof(WGPURenderVertexBufferLayout));
+            if (!vertex_buffers) {
+                free(vertex_entry);
+                free(fragment_entry);
+                NAPI_THROW(env, "createRenderPipeline: out of memory");
+            }
+            if (total_attributes > 0) {
+                vertex_attributes = (WGPURenderVertexAttribute*)calloc(total_attributes, sizeof(WGPURenderVertexAttribute));
+                if (!vertex_attributes) {
+                    free(vertex_buffers);
+                    free(vertex_entry);
+                    free(fragment_entry);
+                    NAPI_THROW(env, "createRenderPipeline: out of memory");
+                }
+            }
+
+            size_t attr_index = 0;
+            for (uint32_t i = 0; i < vertex_buffer_count; i++) {
+                napi_value buffer_desc;
+                napi_get_element(env, buffers, i, &buffer_desc);
+                vertex_buffers[i].nextInChain = NULL;
+                vertex_buffers[i].stepMode = has_prop(env, buffer_desc, "stepMode")
+                    ? vertex_step_mode_from_value(env, get_prop(env, buffer_desc, "stepMode"))
+                    : 0x00000001;
+                vertex_buffers[i].arrayStride = has_prop(env, buffer_desc, "arrayStride")
+                    ? (uint64_t)get_int64_prop(env, buffer_desc, "arrayStride")
+                    : 0;
+                vertex_buffers[i].attributeCount = 0;
+                vertex_buffers[i].attributes = NULL;
+
+                if (prop_type(env, buffer_desc, "attributes") == napi_object) {
+                    napi_value attrs = get_prop(env, buffer_desc, "attributes");
+                    uint32_t attr_count = 0;
+                    napi_get_array_length(env, attrs, &attr_count);
+                    vertex_buffers[i].attributeCount = attr_count;
+                    vertex_buffers[i].attributes = attr_count > 0 ? &vertex_attributes[attr_index] : NULL;
+                    for (uint32_t j = 0; j < attr_count; j++) {
+                        napi_value attr;
+                        napi_get_element(env, attrs, j, &attr);
+                        vertex_attributes[attr_index].nextInChain = NULL;
+                        vertex_attributes[attr_index].format = vertex_format_from_value(env, get_prop(env, attr, "format"));
+                        vertex_attributes[attr_index].offset = has_prop(env, attr, "offset")
+                            ? (uint64_t)get_int64_prop(env, attr, "offset")
+                            : 0;
+                        vertex_attributes[attr_index].shaderLocation = get_uint32_prop(env, attr, "shaderLocation");
+                        attr_index += 1;
+                    }
+                }
+            }
+        }
+    }
+
+    napi_value target0;
+    napi_get_element(env, targets, 0, &target0);
+
+    WGPURenderColorTargetState color_target;
+    memset(&color_target, 0, sizeof(color_target));
+    color_target.nextInChain = NULL;
+    color_target.format = texture_format_from_string(env, get_prop(env, target0, "format"));
+    color_target.blend = NULL;
+    color_target.writeMask = 0xF;
+
+    WGPURenderFragmentState fragment_state;
+    memset(&fragment_state, 0, sizeof(fragment_state));
+    fragment_state.nextInChain = NULL;
+    fragment_state.module = fragment_module;
+    fragment_state.entryPoint.data = fragment_entry;
+    fragment_state.entryPoint.length = fragment_entry_len;
+    fragment_state.constantCount = 0;
+    fragment_state.constants = NULL;
+    fragment_state.targetCount = 1;
+    fragment_state.targets = &color_target;
+
+    WGPURenderPipelineDescriptor desc;
+    memset(&desc, 0, sizeof(desc));
+    desc.nextInChain = NULL;
+    desc.label.data = NULL;
+    desc.label.length = 0;
+    desc.layout = has_prop(env, _args[1], "layout") && prop_type(env, _args[1], "layout") == napi_external
+        ? unwrap_ptr(env, get_prop(env, _args[1], "layout"))
+        : NULL;
+    desc.vertex.nextInChain = NULL;
+    desc.vertex.module = vertex_module;
+    desc.vertex.entryPoint.data = vertex_entry;
+    desc.vertex.entryPoint.length = vertex_entry_len;
+    desc.vertex.constantCount = 0;
+    desc.vertex.constants = NULL;
+    desc.vertex.bufferCount = vertex_buffer_count;
+    desc.vertex.buffers = vertex_buffers;
+    desc.primitive.nextInChain = NULL;
+    desc.primitive.topology = 0x00000004;
+    desc.primitive.stripIndexFormat = 0;
+    desc.primitive.frontFace = 0x00000001;
+    desc.primitive.cullMode = 0x00000001;
+    desc.primitive.unclippedDepth = 0;
+    if (has_prop(env, _args[1], "primitive") && prop_type(env, _args[1], "primitive") == napi_object) {
+        napi_value primitive = get_prop(env, _args[1], "primitive");
+        if (has_prop(env, primitive, "topology"))
+            desc.primitive.topology = primitive_topology_from_string(env, get_prop(env, primitive, "topology"));
+        if (has_prop(env, primitive, "frontFace"))
+            desc.primitive.frontFace = front_face_from_string(env, get_prop(env, primitive, "frontFace"));
+        if (has_prop(env, primitive, "cullMode"))
+            desc.primitive.cullMode = cull_mode_from_string(env, get_prop(env, primitive, "cullMode"));
+        if (has_prop(env, primitive, "unclippedDepth"))
+            desc.primitive.unclippedDepth = get_bool_prop(env, primitive, "unclippedDepth") ? 1 : 0;
+    }
+    desc.depthStencil = NULL;
+    if (has_prop(env, _args[1], "depthStencil") && prop_type(env, _args[1], "depthStencil") == napi_object) {
+        napi_value depth_obj = get_prop(env, _args[1], "depthStencil");
+        depth_stencil = (WGPURenderDepthStencilState*)calloc(1, sizeof(WGPURenderDepthStencilState));
+        if (!depth_stencil) {
+            free(vertex_buffers);
+            free(vertex_attributes);
+            free(vertex_entry);
+            free(fragment_entry);
+            NAPI_THROW(env, "createRenderPipeline: out of memory");
+        }
+        depth_stencil->nextInChain = NULL;
+        depth_stencil->format = texture_format_from_string(env, get_prop(env, depth_obj, "format"));
+        depth_stencil->depthWriteEnabled = has_prop(env, depth_obj, "depthWriteEnabled")
+            ? (get_bool_prop(env, depth_obj, "depthWriteEnabled") ? 1 : 0)
+            : 0;
+        depth_stencil->depthCompare = has_prop(env, depth_obj, "depthCompare")
+            ? compare_func_from_value(env, get_prop(env, depth_obj, "depthCompare"))
+            : 0x00000008;
+        depth_stencil->stencilReadMask = 0xFFFFFFFFu;
+        depth_stencil->stencilWriteMask = 0xFFFFFFFFu;
+        desc.depthStencil = depth_stencil;
+    }
+    desc.multisample.nextInChain = NULL;
+    desc.multisample.count = 1;
+    desc.multisample.mask = 0xFFFFffffu;
+    desc.multisample.alphaToCoverageEnabled = 0;
+    if (has_prop(env, _args[1], "multisample") && prop_type(env, _args[1], "multisample") == napi_object) {
+        napi_value multisample = get_prop(env, _args[1], "multisample");
+        if (has_prop(env, multisample, "count"))
+            desc.multisample.count = get_uint32_prop(env, multisample, "count");
+        if (has_prop(env, multisample, "mask"))
+            desc.multisample.mask = get_uint32_prop(env, multisample, "mask");
+        if (has_prop(env, multisample, "alphaToCoverageEnabled"))
+            desc.multisample.alphaToCoverageEnabled = get_bool_prop(env, multisample, "alphaToCoverageEnabled") ? 1 : 0;
+    }
+    desc.fragment = &fragment_state;
+
+    WGPURenderPipeline rp = pfn_wgpuDeviceCreateRenderPipeline(device, &desc);
+    free(depth_stencil);
+    free(vertex_attributes);
+    free(vertex_buffers);
+    free(vertex_entry);
+    free(fragment_entry);
     if (!rp) NAPI_THROW(env, "createRenderPipeline failed");
     return wrap_ptr(env, rp);
 }
@@ -1876,7 +3003,7 @@ static napi_value doe_render_pipeline_release(napi_env env, napi_callback_info i
 
 /* ================================================================
  * Render Pass
- * beginRenderPass(encoder, colorAttachments[])
+ * beginRenderPass(encoder, descriptor)
  * ================================================================ */
 
 static napi_value doe_begin_render_pass(napi_env env, napi_callback_info info) {
@@ -1885,16 +3012,23 @@ static napi_value doe_begin_render_pass(napi_env env, napi_callback_info info) {
     WGPUCommandEncoder enc = unwrap_ptr(env, _args[0]);
     if (!enc) NAPI_THROW(env, "Invalid encoder");
 
-    /* _args[1] is array of color attachments */
+    if (prop_type(env, _args[1], "colorAttachments") != napi_object) {
+        NAPI_THROW(env, "beginRenderPass requires descriptor.colorAttachments");
+    }
+
+    napi_value color_attachments = get_prop(env, _args[1], "colorAttachments");
     uint32_t att_count = 0;
-    napi_get_array_length(env, _args[1], &att_count);
+    napi_get_array_length(env, color_attachments, &att_count);
     if (att_count == 0) NAPI_THROW(env, "beginRenderPass: need at least one color attachment");
 
     WGPURenderPassColorAttachment* atts = (WGPURenderPassColorAttachment*)calloc(
         att_count, sizeof(WGPURenderPassColorAttachment));
+    WGPURenderPassDepthStencilAttachment depth_att;
+    memset(&depth_att, 0, sizeof(depth_att));
+    bool has_depth_att = false;
     for (uint32_t i = 0; i < att_count; i++) {
         napi_value elem;
-        napi_get_element(env, _args[1], i, &elem);
+        napi_get_element(env, color_attachments, i, &elem);
         atts[i].view = unwrap_ptr(env, get_prop(env, elem, "view"));
         atts[i].loadOp = 1; /* clear */
         atts[i].storeOp = 1; /* store */
@@ -1914,10 +3048,34 @@ static napi_value doe_begin_render_pass(napi_env env, napi_callback_info info) {
         }
     }
 
+    if (has_prop(env, _args[1], "depthStencilAttachment") && prop_type(env, _args[1], "depthStencilAttachment") == napi_object) {
+        napi_value depth_obj = get_prop(env, _args[1], "depthStencilAttachment");
+        depth_att.nextInChain = NULL;
+        depth_att.view = unwrap_ptr(env, get_prop(env, depth_obj, "view"));
+        depth_att.depthLoadOp = 1;
+        depth_att.depthStoreOp = 1;
+        depth_att.depthClearValue = has_prop(env, depth_obj, "depthClearValue")
+            ? (float)get_double_prop(env, depth_obj, "depthClearValue")
+            : 1.0f;
+        depth_att.depthReadOnly = has_prop(env, depth_obj, "depthReadOnly")
+            ? (get_bool_prop(env, depth_obj, "depthReadOnly") ? 1 : 0)
+            : 0;
+        depth_att.stencilLoadOp = 1;
+        depth_att.stencilStoreOp = 1;
+        depth_att.stencilClearValue = has_prop(env, depth_obj, "stencilClearValue")
+            ? get_uint32_prop(env, depth_obj, "stencilClearValue")
+            : 0;
+        depth_att.stencilReadOnly = has_prop(env, depth_obj, "stencilReadOnly")
+            ? (get_bool_prop(env, depth_obj, "stencilReadOnly") ? 1 : 0)
+            : 0;
+        has_depth_att = true;
+    }
+
     WGPURenderPassDescriptor desc;
     memset(&desc, 0, sizeof(desc));
     desc.colorAttachmentCount = att_count;
     desc.colorAttachments = atts;
+    desc.depthStencilAttachment = has_depth_att ? &depth_att : NULL;
 
     WGPURenderPassEncoder pass = pfn_wgpuCommandEncoderBeginRenderPass(enc, &desc);
     free(atts);
@@ -1932,6 +3090,43 @@ static napi_value doe_render_pass_set_pipeline(napi_env env, napi_callback_info
     return NULL;
 }
 
+static napi_value doe_render_pass_set_bind_group(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 3);
+    WGPURenderPassEncoder pass = unwrap_ptr(env, _args[0]);
+    uint32_t index = 0;
+    napi_get_value_uint32(env, _args[1], &index);
+    WGPUBindGroup bg = unwrap_ptr(env, _args[2]);
+    pfn_wgpuRenderPassEncoderSetBindGroup(pass, index, bg, 0, NULL);
+    return NULL;
+}
+
+static napi_value doe_render_pass_set_vertex_buffer(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 5);
+    WGPURenderPassEncoder pass = unwrap_ptr(env, _args[0]);
+    uint32_t slot = 0;
+    uint64_t offset = 0;
+    uint64_t size = 0;
+    napi_get_value_uint32(env, _args[1], &slot);
+    WGPUBuffer buffer = unwrap_ptr(env, _args[2]);
+    offset = (uint64_t)get_int64_value(env, _args[3]);
+    size = (uint64_t)get_int64_value(env, _args[4]);
+    pfn_wgpuRenderPassEncoderSetVertexBuffer(pass, slot, buffer, offset, size);
+    return NULL;
+}
+
+static napi_value doe_render_pass_set_index_buffer(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 5);
+    WGPURenderPassEncoder pass = unwrap_ptr(env, _args[0]);
+    WGPUBuffer buffer = unwrap_ptr(env, _args[1]);
+    uint32_t format = index_format_from_value(env, _args[2]);
+    uint64_t offset = 0;
+    uint64_t size = 0;
+    offset = (uint64_t)get_int64_value(env, _args[3]);
+    size = (uint64_t)get_int64_value(env, _args[4]);
+    pfn_wgpuRenderPassEncoderSetIndexBuffer(pass, buffer, format, offset, size);
+    return NULL;
+}
+
 /* renderPassDraw(pass, vertexCount, instanceCount, firstVertex, firstInstance) */
 static napi_value doe_render_pass_draw(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 5);
@@ -1945,6 +3140,23 @@ static napi_value doe_render_pass_draw(napi_env env, napi_callback_info info) {
     return NULL;
 }
 
+static napi_value doe_render_pass_draw_indexed(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 6);
+    WGPURenderPassEncoder pass = unwrap_ptr(env, _args[0]);
+    uint32_t index_count = 0;
+    uint32_t instance_count = 0;
+    uint32_t first_index = 0;
+    int32_t base_vertex = 0;
+    uint32_t first_instance = 0;
+    napi_get_value_uint32(env, _args[1], &index_count);
+    napi_get_value_uint32(env, _args[2], &instance_count);
+    napi_get_value_uint32(env, _args[3], &first_index);
+    napi_get_value_int32(env, _args[4], &base_vertex);
+    napi_get_value_uint32(env, _args[5], &first_instance);
+    pfn_wgpuRenderPassEncoderDrawIndexed(pass, index_count, instance_count, first_index, base_vertex, first_instance);
+    return NULL;
+}
+
 static napi_value doe_render_pass_end(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 1);
     pfn_wgpuRenderPassEncoderEnd(unwrap_ptr(env, _args[0]));
@@ -1962,21 +3174,12 @@ static napi_value doe_render_pass_release(napi_env env, napi_callback_info info)
  * Device capabilities: limits, features
  * ================================================================ */
 
-static napi_value doe_device_get_limits(napi_env env, napi_callback_info info) {
-    NAPI_ASSERT_ARGC(env, info, 1);
-    CHECK_LIB_LOADED(env);
-    WGPUDevice device = unwrap_ptr(env, _args[0]);
-    if (!device) NAPI_THROW(env, "deviceGetLimits: null device");
-
-    WGPULimits limits;
-    memset(&limits, 0, sizeof(limits));
-    pfn_wgpuDeviceGetLimits(device, &limits);
-
+static napi_value create_limits_object(napi_env env, const WGPULimits* limits) {
     napi_value obj;
     napi_create_object(env, &obj);
 
-#define SET_U32(name) do { napi_value v; napi_create_uint32(env, limits.name, &v); napi_set_named_property(env, obj, #name, v); } while(0)
-#define SET_U64(name) do { napi_value v; napi_create_double(env, (double)limits.name, &v); napi_set_named_property(env, obj, #name, v); } while(0)
+#define SET_U32(name) do { napi_value v; napi_create_uint32(env, limits->name, &v); napi_set_named_property(env, obj, #name, v); } while(0)
+#define SET_U64(name) do { napi_value v; napi_create_double(env, (double)limits->name, &v); napi_set_named_property(env, obj, #name, v); } while(0)
 
     SET_U32(maxTextureDimension1D);
     SET_U32(maxTextureDimension2D);
@@ -2016,18 +3219,192 @@ static napi_value doe_device_get_limits(napi_env env, napi_callback_info info) {
     return obj;
 }
 
+static napi_value doe_device_get_limits(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 1);
+    CHECK_LIB_LOADED(env);
+    WGPUDevice device = unwrap_ptr(env, _args[0]);
+    if (!device) NAPI_THROW(env, "deviceGetLimits: null device");
+    uint32_t (*fn)(WGPUDevice, void*) = pfn_doeNativeDeviceGetLimits ? pfn_doeNativeDeviceGetLimits : pfn_wgpuDeviceGetLimits;
+    if (!fn) {
+        napi_value ret;
+        napi_get_null(env, &ret);
+        return ret;
+    }
+
+    WGPULimits limits;
+    memset(&limits, 0, sizeof(limits));
+    uint32_t status = fn(device, &limits);
+    if (status != WGPU_STATUS_SUCCESS) {
+        napi_value ret;
+        napi_get_null(env, &ret);
+        return ret;
+    }
+
+    return create_limits_object(env, &limits);
+}
+
+static napi_value doe_adapter_get_limits(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 1);
+    CHECK_LIB_LOADED(env);
+    WGPUAdapter adapter = unwrap_ptr(env, _args[0]);
+    if (!adapter) NAPI_THROW(env, "adapterGetLimits: null adapter");
+    uint32_t (*fn)(WGPUAdapter, void*) = pfn_doeNativeAdapterGetLimits ? pfn_doeNativeAdapterGetLimits : pfn_wgpuAdapterGetLimits;
+    if (!fn) {
+        napi_value ret;
+        napi_get_null(env, &ret);
+        return ret;
+    }
+
+    WGPULimits limits;
+    memset(&limits, 0, sizeof(limits));
+    uint32_t status = fn(adapter, &limits);
+    if (status != WGPU_STATUS_SUCCESS) {
+        napi_value ret;
+        napi_get_null(env, &ret);
+        return ret;
+    }
+
+    return create_limits_object(env, &limits);
+}
+
+static napi_value doe_adapter_has_feature(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 2);
+    CHECK_LIB_LOADED(env);
+    WGPUAdapter adapter = unwrap_ptr(env, _args[0]);
+    uint32_t (*fn)(WGPUAdapter, uint32_t) = pfn_doeNativeAdapterHasFeature ? pfn_doeNativeAdapterHasFeature : pfn_wgpuAdapterHasFeature;
+    if (!fn) {
+        napi_value ret;
+        napi_get_boolean(env, false, &ret);
+        return ret;
+    }
+    uint32_t feature;
+    napi_get_value_uint32(env, _args[1], &feature);
+    uint32_t result = fn(adapter, feature);
+    napi_value ret;
+    napi_get_boolean(env, result != 0, &ret);
+    return ret;
+}
+
 static napi_value doe_device_has_feature(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 2);
     CHECK_LIB_LOADED(env);
     WGPUDevice device = unwrap_ptr(env, _args[0]);
+    uint32_t (*fn)(WGPUDevice, uint32_t) = pfn_doeNativeDeviceHasFeature ? pfn_doeNativeDeviceHasFeature : pfn_wgpuDeviceHasFeature;
+    if (!fn) {
+        napi_value ret;
+        napi_get_boolean(env, false, &ret);
+        return ret;
+    }
     uint32_t feature;
     napi_get_value_uint32(env, _args[1], &feature);
-    uint32_t result = pfn_wgpuDeviceHasFeature(device, feature);
+    uint32_t result = fn(device, feature);
     napi_value ret;
     napi_get_boolean(env, result != 0, &ret);
     return ret;
 }
 
+static napi_value doe_get_last_error_stage(napi_env env, napi_callback_info info) {
+    (void)info;
+    char buf[64];
+    copy_library_error_meta(pfn_doeNativeCopyLastErrorStage, buf, sizeof(buf));
+    if (buf[0] == '\0') return NULL;
+    napi_value result;
+    napi_create_string_utf8(env, buf, NAPI_AUTO_LENGTH, &result);
+    return result;
+}
+
+static napi_value doe_get_last_error_kind(napi_env env, napi_callback_info info) {
+    (void)info;
+    char buf[64];
+    copy_library_error_meta(pfn_doeNativeCopyLastErrorKind, buf, sizeof(buf));
+    if (buf[0] == '\0') return NULL;
+    napi_value result;
+    napi_create_string_utf8(env, buf, NAPI_AUTO_LENGTH, &result);
+    return result;
+}
+
+static napi_value doe_get_last_error_line(napi_env env, napi_callback_info info) {
+    (void)info;
+    if (!pfn_doeNativeGetLastErrorLine) return NULL;
+    uint32_t line = pfn_doeNativeGetLastErrorLine();
+    napi_value result;
+    napi_create_uint32(env, line, &result);
+    return result;
+}
+
+static napi_value doe_get_last_error_column(napi_env env, napi_callback_info info) {
+    (void)info;
+    if (!pfn_doeNativeGetLastErrorColumn) return NULL;
+    uint32_t col = pfn_doeNativeGetLastErrorColumn();
+    napi_value result;
+    napi_create_uint32(env, col, &result);
+    return result;
+}
+
+/* ================================================================
+ * QuerySet (timestamp query)
+ * ================================================================ */
+
+static napi_value doe_create_query_set(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 3);
+    CHECK_LIB_LOADED(env);
+    if (!pfn_doeNativeDeviceCreateQuerySet) NAPI_THROW(env, "doeNativeDeviceCreateQuerySet not available");
+    WGPUDevice device = unwrap_ptr(env, _args[0]);
+    if (!device) NAPI_THROW(env, "Invalid device");
+    uint32_t query_type = 0;
+    napi_get_value_uint32(env, _args[1], &query_type);
+    uint32_t count = 0;
+    napi_get_value_uint32(env, _args[2], &count);
+    WGPUQuerySet qs = pfn_doeNativeDeviceCreateQuerySet(device, query_type, count);
+    if (!qs) NAPI_THROW(env, "createQuerySet failed");
+    return wrap_ptr(env, qs);
+}
+
+static napi_value doe_command_encoder_write_timestamp(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 3);
+    CHECK_LIB_LOADED(env);
+    if (!pfn_doeNativeCommandEncoderWriteTimestamp) NAPI_THROW(env, "doeNativeCommandEncoderWriteTimestamp not available");
+    WGPUCommandEncoder enc = unwrap_ptr(env, _args[0]);
+    WGPUQuerySet qs = unwrap_ptr(env, _args[1]);
+    uint32_t query_index = 0;
+    napi_get_value_uint32(env, _args[2], &query_index);
+    pfn_doeNativeCommandEncoderWriteTimestamp(enc, qs, query_index);
+    return NULL;
+}
+
+static napi_value doe_command_encoder_resolve_query_set(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 6);
+    CHECK_LIB_LOADED(env);
+    if (!pfn_doeNativeCommandEncoderResolveQuerySet) NAPI_THROW(env, "doeNativeCommandEncoderResolveQuerySet not available");
+    WGPUCommandEncoder enc = unwrap_ptr(env, _args[0]);
+    WGPUQuerySet qs = unwrap_ptr(env, _args[1]);
+    uint32_t first_query = 0;
+    napi_get_value_uint32(env, _args[2], &first_query);
+    uint32_t query_count = 0;
+    napi_get_value_uint32(env, _args[3], &query_count);
+    WGPUBuffer dst = unwrap_ptr(env, _args[4]);
+    int64_t dst_offset = 0;
+    napi_get_value_int64(env, _args[5], &dst_offset);
+    pfn_doeNativeCommandEncoderResolveQuerySet(enc, qs, first_query, query_count, dst, (uint64_t)dst_offset);
+    return NULL;
+}
+
+static napi_value doe_query_set_destroy(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 1);
+    if (!pfn_doeNativeQuerySetDestroy) return NULL;
+    WGPUQuerySet qs = unwrap_ptr(env, _args[0]);
+    if (qs) pfn_doeNativeQuerySetDestroy(qs);
+    return NULL;
+}
+
+static napi_value doe_set_timeout_ms(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 1);
+    uint32_t timeout_ms = 0;
+    napi_get_value_uint32(env, _args[0], &timeout_ms);
+    g_timeout_ns = (uint64_t)timeout_ms * 1000000ULL;
+    return NULL;
+}
+
 /* ================================================================
  * Module initialization
  * ================================================================ */
@@ -2049,9 +3426,13 @@ static napi_value doe_module_init(napi_env env, napi_value exports) {
         EXPORT_FN("bufferUnmap", doe_buffer_unmap),
         EXPORT_FN("bufferMapSync", doe_buffer_map_sync),
         EXPORT_FN("bufferGetMappedRange", doe_buffer_get_mapped_range),
+        EXPORT_FN("bufferWriteMappedRange", doe_buffer_write_mapped_range),
+        EXPORT_FN("bufferReadIndirectCounts", doe_buffer_read_indirect_counts),
         EXPORT_FN("bufferAssertMappedPrefixF32", doe_buffer_assert_mapped_prefix_f32),
+        EXPORT_FN("checkShaderSource", doe_check_shader_source),
         EXPORT_FN("createShaderModule", doe_create_shader_module),
         EXPORT_FN("shaderModuleRelease", doe_shader_module_release),
+        EXPORT_FN("shaderModuleGetBindings", doe_shader_module_get_bindings),
         EXPORT_FN("createComputePipeline", doe_create_compute_pipeline),
         EXPORT_FN("computePipelineRelease", doe_compute_pipeline_release),
         EXPORT_FN("computePipelineGetBindGroupLayout", doe_compute_pipeline_get_bind_group_layout),
@@ -2064,6 +3445,7 @@ static napi_value doe_module_init(napi_env env, napi_value exports) {
         EXPORT_FN("createCommandEncoder", doe_create_command_encoder),
         EXPORT_FN("commandEncoderRelease", doe_command_encoder_release),
         EXPORT_FN("commandEncoderCopyBufferToBuffer", doe_command_encoder_copy_buffer_to_buffer),
+        EXPORT_FN("commandEncoderCopyTextureToBuffer", doe_command_encoder_copy_texture_to_buffer),
         EXPORT_FN("commandEncoderFinish", doe_command_encoder_finish),
         EXPORT_FN("commandBufferRelease", doe_command_buffer_release),
         EXPORT_FN("beginComputePass", doe_begin_compute_pass),
@@ -2090,11 +3472,26 @@ static napi_value doe_module_init(napi_env env, napi_value exports) {
         EXPORT_FN("renderPipelineRelease", doe_render_pipeline_release),
         EXPORT_FN("beginRenderPass", doe_begin_render_pass),
         EXPORT_FN("renderPassSetPipeline", doe_render_pass_set_pipeline),
+        EXPORT_FN("renderPassSetBindGroup", doe_render_pass_set_bind_group),
+        EXPORT_FN("renderPassSetVertexBuffer", doe_render_pass_set_vertex_buffer),
+        EXPORT_FN("renderPassSetIndexBuffer", doe_render_pass_set_index_buffer),
         EXPORT_FN("renderPassDraw", doe_render_pass_draw),
+        EXPORT_FN("renderPassDrawIndexed", doe_render_pass_draw_indexed),
         EXPORT_FN("renderPassEnd", doe_render_pass_end),
         EXPORT_FN("renderPassRelease", doe_render_pass_release),
+        EXPORT_FN("adapterGetLimits", doe_adapter_get_limits),
+        EXPORT_FN("adapterHasFeature", doe_adapter_has_feature),
         EXPORT_FN("deviceGetLimits", doe_device_get_limits),
         EXPORT_FN("deviceHasFeature", doe_device_has_feature),
+        EXPORT_FN("createQuerySet", doe_create_query_set),
+        EXPORT_FN("commandEncoderWriteTimestamp", doe_command_encoder_write_timestamp),
+        EXPORT_FN("commandEncoderResolveQuerySet", doe_command_encoder_resolve_query_set),
+        EXPORT_FN("querySetDestroy", doe_query_set_destroy),
+        EXPORT_FN("setTimeoutMs", doe_set_timeout_ms),
+        EXPORT_FN("getLastErrorStage", doe_get_last_error_stage),
+        EXPORT_FN("getLastErrorKind", doe_get_last_error_kind),
+        EXPORT_FN("getLastErrorLine", doe_get_last_error_line),
+        EXPORT_FN("getLastErrorColumn", doe_get_last_error_column),
     };
 
     size_t count = sizeof(descriptors) / sizeof(descriptors[0]);