@forgeax/engine-rhi-webgpu 0.1.4 → 0.1.6

package/dist/internal/timestamp-query.d.ts

@@ -1,24 +1,4 @@
 import { type Result, RhiError } from '@forgeax/engine-rhi';
-export type TimestampQueryHealthCode = 'timestamp-query-unsupported' | 'timestamp-query-encoder-missing' | 'timestamp-query-generation-mismatch';
-export interface TimestampQueryHealth {
-    readonly status: 'ready' | 'fault';
-    readonly code: TimestampQueryHealthCode | undefined;
-    readonly expected: string;
-    readonly hint: string;
-    readonly deviceGeneration: number;
-    readonly expectedGeneration: number | undefined;
-}
-/**
- * Keep timestamp capability and device-generation checks structured. This is
- * also the health vocabulary used by recovery callers; a missing capability
- * or stale encoder is never reported as a fabricated timing interval.
- */
-export declare function timestampQueryHealth(input: {
-    readonly capability: boolean;
-    readonly encoderWriteTimestamp: boolean;
-    readonly deviceGeneration: number;
-    readonly expectedGeneration?: number | undefined;
-}): TimestampQueryHealth;
 export declare function resolveTimestampQueries(args: {
     rawEncoder: GPUCommandEncoder;
     rawQuerySet: GPUQuerySet;
@@ -26,14 +6,10 @@ export declare function resolveTimestampQueries(args: {
     queryCount: number;
     rawDestination: GPUBuffer;
     destinationOffset: number;
-    readonly deviceGeneration?: number;
-    readonly expectedGeneration?: number;
 }): Result<void, RhiError>;
 export declare function writeTimestamp(args: {
     rawEncoder: GPUCommandEncoder;
     rawQuerySet: GPUQuerySet;
     queryIndex: number;
-    readonly deviceGeneration?: number;
-    readonly expectedGeneration?: number;
 }): void;
 //# sourceMappingURL=timestamp-query.d.ts.map

package/dist/internal/timestamp-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timestamp-query.d.ts","sourceRoot":"","sources":["../../src/internal/timestamp-query.ts"],"names":[],"mappings":"AAEA,OAAO,EAAW,KAAK,MAAM,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAErE,MAAM,MAAM,wBAAwB,GAChC,6BAA6B,GAC7B,iCAAiC,GACjC,qCAAqC,CAAC;AAE1C,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;CACjD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;IACxC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClD,GAAG,oBAAoB,CA0CvB;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,UAAU,EAAE,iBAAiB,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,SAAS,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACtC,GAAG,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAuCzB;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACtC,GAAG,IAAI,CAsCP"}
+{"version":3,"file":"timestamp-query.d.ts","sourceRoot":"","sources":["../../src/internal/timestamp-query.ts"],"names":[],"mappings":"AAEA,OAAO,EAAW,KAAK,MAAM,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAErE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,UAAU,EAAE,iBAAiB,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,SAAS,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GAAG,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAoBzB;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,IAAI,CAqBP"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-rhi-webgpu",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -22,8 +22,8 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-rhi": "0.1.4",
-    "@forgeax/engine-types": "0.1.4",
+    "@forgeax/engine-rhi": "0.1.6",
+    "@forgeax/engine-types": "0.1.6",
     "@webgpu/types": "^0.1.71"
   },
   "forgeax": {

package/src/__tests__/__mocks__/gpu-device.ts

@@ -52,14 +52,6 @@ export interface MockFailures {
 export type MockCapture =
   | { kind: 'requestAdapter'; options: GPURequestAdapterOptions | undefined }
   | { kind: 'requestDevice'; options: GPUDeviceDescriptor | undefined }
-  | {
-      kind: 'writeBuffer';
-      buffer: MockBuffer;
-      bufferOffset: number;
-      data: ArrayBufferView | ArrayBuffer;
-      dataOffset: number | undefined;
-      size: number | undefined;
-    }
   | { kind: 'createBuffer'; descriptor: GPUBufferDescriptor }
   | { kind: 'createTexture'; descriptor: GPUTextureDescriptor }
   | { kind: 'createSampler'; descriptor: GPUSamplerDescriptor | undefined }
@@ -308,9 +300,8 @@ function makeDevice(captured: MockCapture[], failures: MockFailures): MockDevice
       // No-op; w6 unit tests assert the shim wiring + bounds error paths
       // before the call would reach the real GPU layer.
     },
-    writeBuffer(buffer, bufferOffset, data, dataOffset, size): void {
+    writeBuffer(_buffer, _bufferOffset, _data, _dataOffset, _size): void {
       // No-op; bounds checks happen in the shim before this is reached.
-      captured.push({ kind: 'writeBuffer', buffer, bufferOffset, data, dataOffset, size });
     },
     writeTexture(_destination, _data, _dataLayout, _size): void {
       // No-op; alignment validation happens in the shim before this is hit.

package/src/__tests__/dawn-real-gpu.dawn.test.ts

@@ -61,49 +61,6 @@ async function requestRhiDevice(): Promise<RhiDevice | undefined> {
   return deviceResult.value;
 }
 
-describe('dawn-real-gpu - queue.writeBuffer typed range', () => {
-  it('reads back exactly the selected typed-array elements', async () => {
-    const device = await requestRhiDevice();
-    if (device === undefined) return;
-    const targetResult = device.createBuffer({
-      label: 'dawn-write-range-target',
-      size: 32,
-      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
-    });
-    const readbackResult = device.createBuffer({
-      label: 'dawn-write-range-readback',
-      size: 32,
-      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
-    });
-    expect(targetResult.ok && readbackResult.ok).toBe(true);
-    if (!targetResult.ok || !readbackResult.ok) return;
-
-    const source = new Float32Array([10, 20, 30, 40, 50]);
-    const write = device.queue.writeBuffer(targetResult.value, 0, source, 1, 2);
-    expect(write.ok).toBe(true);
-    if (!write.ok) return;
-
-    const encoderResult = device.createCommandEncoder({ label: 'dawn-write-range-copy' });
-    expect(encoderResult.ok).toBe(true);
-    if (!encoderResult.ok) return;
-    encoderResult.value.copyBufferToBuffer(targetResult.value, 0, readbackResult.value, 0, 32);
-    const finish = encoderResult.value.finish();
-    expect(finish.ok).toBe(true);
-    if (!finish.ok) return;
-    expect(device.queue.submit([finish.value]).ok).toBe(true);
-    await device.queue.onSubmittedWorkDone();
-
-    const mapped = await readbackResult.value.mapAsync(GPUMapMode.READ);
-    expect(mapped.ok).toBe(true);
-    if (!mapped.ok) return;
-    const range = mapped.value.getMappedRange();
-    expect(range.ok).toBe(true);
-    if (!range.ok) return;
-    expect(Array.from(new Float32Array(range.value.slice(0)))).toEqual([20, 30, 0, 0, 0, 0, 0, 0]);
-    mapped.value.unmap();
-  });
-});
-
 function reportTimestampEvidence(evidence: Record<string, unknown>): void {
   // biome-ignore lint/suspicious/noConsole: the dawn admission record is the test evidence output
   console.log(JSON.stringify(evidence));

package/src/__tests__/rhi-webgpu.unit.test.ts

@@ -685,7 +685,7 @@ import { createMockGpu, type MockCapture, makeShaderError } from './__mocks__/gp
       const desc: RenderPipelineDescriptor = {
         label: 'rpp',
         layout: 'auto',
-        vertex: { module: shader.value as unknown as GPUShaderModule, entryPoint: 'v' },
+        vertex: { module: shader.value, entryPoint: 'v', buffers: [] },
         fragment: undefined,
       };
       const out = device.createRenderPipeline(desc);
@@ -703,12 +703,17 @@ import { createMockGpu, type MockCapture, makeShaderError } from './__mocks__/gp
       if (!r.ok) throw new Error('mock requestDevice failed');
       const device = r.value;
 
+      const shader = await createShaderModule(device, {
+        code: '@vertex fn v() -> @builtin(position) vec4f { return vec4f(0); }',
+      });
+      if (!shader.ok) throw new Error('mock shader creation failed');
       const out = device.createRenderPipeline({
         label: 'invalid-rpp',
         layout: 'auto',
         vertex: {
-          module: {} as unknown as GPUShaderModule,
+          module: shader.value,
           entryPoint: 'v',
+          buffers: [],
         },
         fragment: undefined,
       });
@@ -1653,45 +1658,6 @@ import { createMockGpu, type MockCapture, makeShaderError } from './__mocks__/gp
         expect(out.error.code).toBe('queue-write-buffer-out-of-bounds');
       }
     });
-
-    it('interprets Float32Array dataOffset and size as elements for bounds', async () => {
-      const gpu = createMockGpu();
-      const r = await requestDevice({ gpu });
-      if (!r.ok) throw new Error('mock requestDevice should not fail');
-      const device = r.value as unknown as DeviceLike;
-      const bufResult = device.createBuffer({ size: 8, usage: 0 });
-      if (!bufResult.ok) throw new Error('createBuffer should succeed');
-      const data = new Float32Array(4);
-      const out = device.queue.writeBuffer(bufResult.value, 0, data, 1, 3);
-      expect(out.ok).toBe(false);
-      if (!out.ok) expect(out.error.code).toBe('queue-write-buffer-out-of-bounds');
-    });
-
-    it('forwards a non-zero Float32 view and element range without byte reinterpretation', async () => {
-      const gpu = createMockGpu();
-      const r = await requestDevice({ gpu });
-      if (!r.ok) throw new Error('mock requestDevice should not fail');
-      const device = r.value as unknown as DeviceLike;
-      const bufResult = device.createBuffer({ size: 16, usage: 0 });
-      if (!bufResult.ok) throw new Error('createBuffer should succeed');
-      const source = new Float32Array([10, 20, 30, 40, 50]);
-      const view = source.subarray(1);
-      const out = device.queue.writeBuffer(bufResult.value, 0, view, 1, 2);
-      expect(out.ok).toBe(true);
-      const event = [...gpu.__captured].reverse().find((entry) => entry.kind === 'writeBuffer');
-      expect(event?.kind).toBe('writeBuffer');
-      if (event?.kind !== 'writeBuffer') return;
-      expect(event.data).toBe(view);
-      expect(event.dataOffset).toBe(1);
-      expect(event.size).toBe(2);
-      if (!ArrayBuffer.isView(event.data)) return;
-      const selected = new Uint8Array(
-        event.data.buffer,
-        event.data.byteOffset + (event.dataOffset ?? 0) * Float32Array.BYTES_PER_ELEMENT,
-        (event.size ?? 0) * Float32Array.BYTES_PER_ELEMENT,
-      );
-      expect([...selected]).toEqual([...new Uint8Array(source.buffer, 2 * 4, 8)]);
-    });
   });
 
   // ---------------------------------------------------------------------------

package/src/device.ts

@@ -40,11 +40,13 @@ import type {
   ComputePassDescriptor,
   ComputePipeline,
   ComputePipelineDescriptor,
+  ExternalImageTextureDestination,
   MappedBuffer,
   PipelineLayout,
   PipelineLayoutDescriptor,
   QuerySet,
   QuerySetDescriptor,
+  RenderPassDescriptor,
   RenderPipeline,
   RenderPipelineDescriptor,
   Result,
@@ -64,8 +66,9 @@ import type {
   TextureDescriptor,
   TextureView,
   TextureViewDescriptor,
+  TextureWriteDestination,
 } from '@forgeax/engine-rhi';
-import { err, ok, RhiError as RhiErrorClass, resolveBufferWriteRange } from '@forgeax/engine-rhi';
+import { err, ok, RhiError as RhiErrorClass } from '@forgeax/engine-rhi';
 import {
   commandEncoderFinished,
   queueSubmitFailed,
@@ -132,15 +135,6 @@ const BGL_KEYS = ['label', 'entries'] as const;
 // BG_KEYS removed in w20 — createBindGroup now uses tagged-union dispatch
 // over RhiBindingResource 4 kinds (not field-mirror passthrough).
 const PL_KEYS = ['label', 'bindGroupLayouts'] as const;
-const RPP_KEYS = [
-  'label',
-  'layout',
-  'vertex',
-  'primitive',
-  'depthStencil',
-  'multisample',
-  'fragment',
-] as const;
 const ENC_KEYS = ['label'] as const;
 const TEXTURE_VIEW_KEYS = [
   'label',
@@ -174,6 +168,7 @@ const QUERY_SET_COUNT_LIMIT = 4096;
  */
 const RAW_DEVICE_MAP: WeakMap<RhiDevice, GPUDevice> = new WeakMap();
 const BUFFER_RAW_MAP: WeakMap<Buffer, GPUBuffer> = new WeakMap();
+const TEXTURE_VIEW_RAW_MAP: WeakMap<TextureView, GPUTextureView> = new WeakMap();
 const ENCODER_STATE: WeakMap<RhiCommandEncoder, EncoderState> = new WeakMap();
 const PASS_STATE: WeakMap<RhiRenderPassEncoder, PassState> = new WeakMap();
 const COMMAND_BUFFER_RAW_MAP: WeakMap<CommandBuffer, GPUCommandBuffer> = new WeakMap();
@@ -271,7 +266,7 @@ const QUERY_RESOLVE_ALIGNMENT = 256;
  * The `_internal_` prefix + `@internal` JSDoc tag mark this as engine-internal
  * plumbing; the only sanctioned consumer is
  * `apps/hello/triangle/src/main.ts:96` which threads the raw GPUDevice into
- * `RendererOptions.rawDeviceForContextConfigure` so the canvas
+ * the host's internal canvas-device configuration slot so the canvas
  * `GPUCanvasContext.configure({device})` slot keeps working
  * (GPUCanvasContext is outside the RHI surface). Every other engine path
  * goes through the RHI interface.
@@ -510,12 +505,7 @@ function makeRenderPassEncoder(
       rawPass.setViewport(x, y, w, h, minDepth, maxDepth);
     },
     setScissorRect(x: number, y: number, w: number, h: number): void {
-      const setScissorRect = (
-        rawPass as unknown as {
-          readonly setScissorRect?: (x: number, y: number, w: number, h: number) => void;
-        }
-      ).setScissorRect;
-      setScissorRect?.call(rawPass, x, y, w, h);
+      rawPass.setScissorRect(x, y, w, h);
     },
     setBlendConstant(color: GPUColor): void {
       rawPass.setBlendConstant(color);
@@ -692,6 +682,123 @@ function throwIfFinished(state: EncoderState | undefined): void {
   }
 }
 
+function rawTextureView(view: TextureView): GPUTextureView {
+  return TEXTURE_VIEW_RAW_MAP.get(view) ?? (view as unknown as GPUTextureView);
+}
+
+function mirrorRenderPassDescriptor(desc: RenderPassDescriptor): GPURenderPassDescriptor {
+  const colorAttachments: Array<GPURenderPassColorAttachment | null> = [];
+  for (const attachment of desc.colorAttachments) {
+    if (attachment === null || attachment === undefined) {
+      colorAttachments.push(null);
+      continue;
+    }
+    if (attachment.loadOp === undefined || attachment.storeOp === undefined) {
+      throw new TypeError('RHI render-pass color attachments require loadOp and storeOp');
+    }
+    colorAttachments.push({
+      view: rawTextureView(attachment.view),
+      ...(attachment.depthSlice === undefined ? {} : { depthSlice: attachment.depthSlice }),
+      ...(attachment.resolveTarget === undefined
+        ? {}
+        : { resolveTarget: rawTextureView(attachment.resolveTarget) }),
+      ...(attachment.clearValue === undefined ? {} : { clearValue: attachment.clearValue }),
+      loadOp: attachment.loadOp,
+      storeOp: attachment.storeOp,
+    });
+  }
+
+  return {
+    ...(desc.label === undefined ? {} : { label: desc.label }),
+    colorAttachments,
+    ...(desc.depthStencilAttachment === undefined
+      ? {}
+      : {
+          depthStencilAttachment: {
+            view: rawTextureView(desc.depthStencilAttachment.view),
+            ...(desc.depthStencilAttachment.depthClearValue === undefined
+              ? {}
+              : { depthClearValue: desc.depthStencilAttachment.depthClearValue }),
+            ...(desc.depthStencilAttachment.depthLoadOp === undefined
+              ? {}
+              : { depthLoadOp: desc.depthStencilAttachment.depthLoadOp }),
+            ...(desc.depthStencilAttachment.depthStoreOp === undefined
+              ? {}
+              : { depthStoreOp: desc.depthStencilAttachment.depthStoreOp }),
+            ...(desc.depthStencilAttachment.depthReadOnly === undefined
+              ? {}
+              : { depthReadOnly: desc.depthStencilAttachment.depthReadOnly }),
+            ...(desc.depthStencilAttachment.stencilClearValue === undefined
+              ? {}
+              : { stencilClearValue: desc.depthStencilAttachment.stencilClearValue }),
+            ...(desc.depthStencilAttachment.stencilLoadOp === undefined
+              ? {}
+              : { stencilLoadOp: desc.depthStencilAttachment.stencilLoadOp }),
+            ...(desc.depthStencilAttachment.stencilStoreOp === undefined
+              ? {}
+              : { stencilStoreOp: desc.depthStencilAttachment.stencilStoreOp }),
+            ...(desc.depthStencilAttachment.stencilReadOnly === undefined
+              ? {}
+              : { stencilReadOnly: desc.depthStencilAttachment.stencilReadOnly }),
+          },
+        }),
+    ...(desc.occlusionQuerySet === undefined
+      ? {}
+      : {
+          occlusionQuerySet:
+            QUERY_SET_RAW_MAP.get(desc.occlusionQuerySet) ??
+            (desc.occlusionQuerySet as unknown as GPUQuerySet),
+        }),
+    ...(desc.timestampWrites === undefined
+      ? {}
+      : {
+          timestampWrites: {
+            querySet:
+              QUERY_SET_RAW_MAP.get(desc.timestampWrites.querySet) ??
+              (desc.timestampWrites.querySet as unknown as GPUQuerySet),
+            ...(desc.timestampWrites.beginningOfPassWriteIndex === undefined
+              ? {}
+              : { beginningOfPassWriteIndex: desc.timestampWrites.beginningOfPassWriteIndex }),
+            ...(desc.timestampWrites.endOfPassWriteIndex === undefined
+              ? {}
+              : { endOfPassWriteIndex: desc.timestampWrites.endOfPassWriteIndex }),
+          },
+        }),
+    ...(desc.maxDrawCount === undefined ? {} : { maxDrawCount: desc.maxDrawCount }),
+  };
+}
+
+function mirrorRenderPipelineDescriptor(
+  desc: RenderPipelineDescriptor,
+): GPURenderPipelineDescriptor {
+  const vertex: GPUVertexState = {
+    module: desc.vertex.module as unknown as GPUShaderModule,
+    ...(desc.vertex.buffers === undefined ? {} : { buffers: Array.from(desc.vertex.buffers) }),
+    ...(desc.vertex.entryPoint === undefined ? {} : { entryPoint: desc.vertex.entryPoint }),
+    ...(desc.vertex.constants === undefined ? {} : { constants: desc.vertex.constants }),
+  };
+  const fragment: GPUFragmentState | undefined =
+    desc.fragment === undefined
+      ? undefined
+      : {
+          module: desc.fragment.module as unknown as GPUShaderModule,
+          targets: Array.from(desc.fragment.targets),
+          ...(desc.fragment.entryPoint === undefined
+            ? {}
+            : { entryPoint: desc.fragment.entryPoint }),
+          ...(desc.fragment.constants === undefined ? {} : { constants: desc.fragment.constants }),
+        };
+  return {
+    ...(desc.label === undefined ? {} : { label: desc.label }),
+    layout: desc.layout === 'auto' ? 'auto' : (desc.layout as unknown as GPUPipelineLayout),
+    vertex,
+    ...(desc.primitive === undefined ? {} : { primitive: desc.primitive }),
+    ...(desc.depthStencil === undefined ? {} : { depthStencil: desc.depthStencil }),
+    ...(desc.multisample === undefined ? {} : { multisample: desc.multisample }),
+    ...(fragment === undefined ? {} : { fragment }),
+  };
+}
+
 /**
  * Build a RhiCommandEncoder around a raw GPUCommandEncoder (w3).
  *
@@ -736,17 +843,16 @@ function makeCommandEncoder(
   }
 
   const enc: RhiCommandEncoder = {
-    beginRenderPass(desc: GPURenderPassDescriptor): RhiRenderPassEncoder {
+    beginRenderPass(desc: RenderPassDescriptor): RhiRenderPassEncoder {
       const state = ENCODER_STATE.get(enc);
       throwIfFinished(state);
-      const rawPass = rawEncoder.beginRenderPass(desc);
+      const rawPass = rawEncoder.beginRenderPass(mirrorRenderPassDescriptor(desc));
       // Extract occlusionQuerySet from the descriptor (research §2.2:
       // RPDesc.occlusionQuerySet is the injection point; the render pass
       // PassState.[[occlusion_query_set]] mirrors it). The forgeax
       // RenderPassDescriptor declares occlusionQuerySet as `QuerySet |
       // undefined`; the raw GPU descriptor is structurally compatible.
-      const occQs = (desc as unknown as { occlusionQuerySet?: unknown }).occlusionQuerySet;
-      const occlusionQuerySet = occQs === undefined || occQs === null ? null : (occQs as QuerySet);
+      const occlusionQuerySet = desc.occlusionQuerySet ?? null;
       const pass = makeRenderPassEncoder(rawPass, enc, occlusionQuerySet);
       if (state !== undefined) state.activePass = pass;
       return pass;
@@ -1214,7 +1320,6 @@ function makeQueue(rawQueue: GPUQueue): RhiQueue {
       size?: number | undefined,
     ): Result<void, RhiError> {
       const rawBuffer = BUFFER_RAW_MAP.get(buffer) ?? (buffer as unknown as GPUBuffer);
-      const range = resolveBufferWriteRange(data, dataOffset, size);
       const bufferSize =
         typeof (rawBuffer as { size?: number }).size === 'number'
           ? (rawBuffer as { size: number }).size
@@ -1223,13 +1328,17 @@ function makeQueue(rawQueue: GPUQueue): RhiQueue {
       if (bufferOffset % 4 !== 0) {
         return queueWriteBufferOutOfBounds({
           offset: bufferOffset,
-          byteLength: range?.byteSize ?? 0,
+          byteLength:
+            data instanceof ArrayBuffer ? data.byteLength : (data as ArrayBufferView).byteLength,
           bufferSize,
         });
       }
-      const writeSize = range?.byteSize ?? 0;
+      const dataByteLength =
+        data instanceof ArrayBuffer ? data.byteLength : (data as ArrayBufferView).byteLength;
+      const writeStart = dataOffset ?? 0;
+      const writeSize = size ?? dataByteLength - writeStart;
       // Bounds validation: bufferOffset + writeSize <= bufferSize.
-      if (range === undefined || bufferOffset + writeSize > bufferSize) {
+      if (bufferOffset + writeSize > bufferSize) {
         return queueWriteBufferOutOfBounds({
           offset: bufferOffset,
           byteLength: writeSize,
@@ -1242,15 +1351,15 @@ function makeQueue(rawQueue: GPUQueue): RhiQueue {
             rawBuffer,
             bufferOffset,
             data as GPUAllowSharedBufferSource,
-            range.sourceOffset,
-            range.sourceSize,
+            writeStart,
+            size,
           );
         } else if (dataOffset !== undefined) {
           rawQueue.writeBuffer(
             rawBuffer,
             bufferOffset,
             data as GPUAllowSharedBufferSource,
-            range.sourceOffset,
+            writeStart,
           );
         } else {
           rawQueue.writeBuffer(rawBuffer, bufferOffset, data as GPUAllowSharedBufferSource);
@@ -1289,7 +1398,7 @@ function makeQueue(rawQueue: GPUQueue): RhiQueue {
       }
     },
     writeTexture(
-      destination: GPUTexelCopyTextureInfo,
+      destination: TextureWriteDestination,
       data: ArrayBufferView | ArrayBuffer,
       dataLayout: GPUTexelCopyBufferLayout,
       size: GPUExtent3DStrict,
@@ -1309,8 +1418,14 @@ function makeQueue(rawQueue: GPUQueue): RhiQueue {
         // structural compatibility lets us forward verbatim with a cast.
         // The data + size casts cover @webgpu/types polymorphism that the
         // forgeax form normalises to the strict spec subset.
+        const rawDestination: GPUTexelCopyTextureInfo = {
+          texture: destination.texture as unknown as GPUTexture,
+        };
+        if (destination.mipLevel !== undefined) rawDestination.mipLevel = destination.mipLevel;
+        if (destination.origin !== undefined) rawDestination.origin = destination.origin;
+        if (destination.aspect !== undefined) rawDestination.aspect = destination.aspect;
         rawQueue.writeTexture(
-          destination,
+          rawDestination,
           data as unknown as GPUAllowSharedBufferSource,
           dataLayout,
           size as unknown as GPUExtent3D,
@@ -1329,11 +1444,24 @@ function makeQueue(rawQueue: GPUQueue): RhiQueue {
     },
     copyExternalImageToTexture(
       source: GPUCopyExternalImageSourceInfo,
-      destination: GPUCopyExternalImageDestInfo,
+      destination: ExternalImageTextureDestination,
       copySize: GPUExtent3DStrict,
     ): Result<void, RhiError> {
       try {
-        rawQueue.copyExternalImageToTexture(source, destination, copySize);
+        rawQueue.copyExternalImageToTexture(
+          source,
+          {
+            texture: destination.texture as unknown as GPUTexture,
+            ...(destination.mipLevel === undefined ? {} : { mipLevel: destination.mipLevel }),
+            ...(destination.origin === undefined ? {} : { origin: destination.origin }),
+            ...(destination.aspect === undefined ? {} : { aspect: destination.aspect }),
+            ...(destination.colorSpace === undefined ? {} : { colorSpace: destination.colorSpace }),
+            ...(destination.premultipliedAlpha === undefined
+              ? {}
+              : { premultipliedAlpha: destination.premultipliedAlpha }),
+          },
+          copySize,
+        );
         return ok(undefined);
       } catch (e) {
         const message = e instanceof Error ? e.message : String(e);
@@ -1538,7 +1666,9 @@ export function makeRhiDevice(rawDevice: GPUDevice): {
         const rawView = rawTexture.createView(
           mirror(desc, TEXTURE_VIEW_KEYS) as unknown as GPUTextureViewDescriptor,
         );
-        return ok(rawView as unknown as TextureView);
+        const handle = rawView as unknown as TextureView;
+        TEXTURE_VIEW_RAW_MAP.set(handle, rawView);
+        return ok(handle);
       } catch (e) {
         const message = e instanceof Error ? e.message : String(e);
         return err(
@@ -1638,9 +1768,7 @@ export function makeRhiDevice(rawDevice: GPUDevice): {
     },
     createRenderPipeline(desc: RenderPipelineDescriptor): Result<RenderPipeline, RhiError> {
       try {
-        const out = rawDevice.createRenderPipeline(
-          mirror(desc, RPP_KEYS) as unknown as GPURenderPipelineDescriptor,
-        );
+        const out = rawDevice.createRenderPipeline(mirrorRenderPipelineDescriptor(desc));
         return ok(out as unknown as RenderPipeline);
       } catch (e) {
         const message = e instanceof Error ? e.message : String(e);