@forgeax/engine-rhi-debug 0.1.28 → 0.1.29

package/dist/index.mjs

@@ -4294,11 +4294,14 @@ var eventKinds = [
   "frameMark",
   "createBuffer",
   "createTexture",
+  "createQuerySet",
   "destroyBuffer",
   "destroyTexture",
+  "destroyQuerySet",
   "createTextureView",
   "createSampler",
   "createBindGroupLayout",
+  "getBindGroupLayout",
   "createBindGroup",
   "createPipelineLayout",
   "createRenderPipeline",
@@ -4310,12 +4313,15 @@ var eventKinds = [
   "copyExternalImageToTexture",
   "submit",
   "beginRenderPass",
+  "beginOcclusionQuery",
+  "endOcclusionQuery",
   "beginComputePass",
   "copyBufferToBuffer",
   "copyBufferToTexture",
   "copyTextureToBuffer",
   "copyTextureToTexture",
   "clearBuffer",
+  "resolveQuerySet",
   "pushDebugGroup",
   "popDebugGroup",
   "insertDebugMarker",
@@ -4362,6 +4368,8 @@ function resourceKindForEvent(kind) {
       return "buffer";
     case "createTexture":
       return "texture";
+    case "createQuerySet":
+      return "query-set";
     case "createTextureView":
       return "texture-view";
     case "createSampler":
@@ -4373,6 +4381,7 @@ function resourceKindForEvent(kind) {
       return "pipeline";
     case "createBindGroup":
     case "createBindGroupLayout":
+    case "getBindGroupLayout":
     case "createPipelineLayout":
       return "binding";
     case "createCommandEncoder":
@@ -4388,12 +4397,12 @@ function semanticsFor(kind) {
     created: (event) => createdHandles(event),
     read: (event) => referencedHandles(event),
     written: (event) => writtenHandles(event),
-    destroyed: (event) => event.kind === "destroyBuffer" || event.kind === "destroyTexture" ? stringField(event, "handleId") : []
+    destroyed: (event) => event.kind === "destroyBuffer" || event.kind === "destroyTexture" || event.kind === "destroyQuerySet" ? stringField(event, "handleId") : []
   };
 }
 function categoryFor(kind) {
   if (isWorkEvent(kind)) return "work";
-  if (kind.startsWith("create") || kind.startsWith("destroy") || kind === "initialData")
+  if (kind.startsWith("create") || kind.startsWith("destroy") || kind === "initialData" || kind === "getBindGroupLayout")
     return "resource";
   if (kind.includes("Pass")) return "pass";
   if (kind.startsWith("copy") || kind === "clearBuffer" || kind.startsWith("write")) return "copy";
@@ -4422,6 +4431,8 @@ function referencedHandles(event) {
     "resourceHandleIds",
     "bindGroupHandleId",
     "pipelineHandleId",
+    "querySetHandleId",
+    "occlusionQuerySetHandleId",
     "indexBufferHandleId",
     "vertexBufferHandleId"
   ];
@@ -5256,6 +5267,7 @@ function isResourceKind(value) {
   return [
     "buffer",
     "texture",
+    "query-set",
     "texture-view",
     "sampler",
     "shader-module",
@@ -5268,8 +5280,10 @@ function eventResources(event) {
   switch (event.kind) {
     case "createBuffer":
     case "createTexture":
+    case "createQuerySet":
     case "createSampler":
     case "createBindGroupLayout":
+    case "getBindGroupLayout":
     case "createBindGroup":
     case "createPipelineLayout":
     case "createRenderPipeline":
@@ -5279,6 +5293,7 @@ function eventResources(event) {
         created: [event.handleId],
         reads: handleRefs(event, [
           "layoutHandleId",
+          "pipelineHandleId",
           "vertexShaderModuleHandleId",
           "fragmentShaderModuleHandleId",
           "computeShaderModuleHandleId"
@@ -5291,6 +5306,7 @@ function eventResources(event) {
       return { created: [event.cmdHandleId], reads: [], destroyed: [] };
     case "destroyBuffer":
     case "destroyTexture":
+    case "destroyQuerySet":
       return { created: [], reads: [event.handleId], destroyed: [event.handleId] };
     case "writeBuffer":
     case "writeTexture":
@@ -5312,6 +5328,32 @@ function eventResources(event) {
         ]),
         destroyed: []
       };
+    case "resolveQuerySet":
+      return {
+        created: [],
+        reads: handleRefs(event, ["cmdHandleId", "querySetHandleId", "destinationHandleId"]),
+        destroyed: []
+      };
+    case "beginRenderPass":
+      return {
+        created: [event.passHandleId],
+        reads: handleRefs(event, [
+          "cmdHandleId",
+          "occlusionQuerySetHandleId",
+          "colorAttachmentViewHandleIds",
+          "colorAttachmentResolveTargetHandleIds",
+          "depthStencilViewHandleId"
+        ]),
+        destroyed: []
+      };
+    case "beginComputePass":
+      return { created: [event.passHandleId], reads: [event.cmdHandleId], destroyed: [] };
+    case "endRenderPass":
+    case "endComputePass":
+      return { created: [], reads: [event.passHandleId], destroyed: [event.passHandleId] };
+    case "beginOcclusionQuery":
+    case "endOcclusionQuery":
+      return { created: [], reads: handleRefs(event, ["passHandleId"]), destroyed: [] };
     default:
       return { created: [], reads: [], destroyed: [] };
   }
@@ -6098,7 +6140,8 @@ function createdHandleId(event) {
   if (event.kind === "beginRenderPass" || event.kind === "beginComputePass") {
     return event.passHandleId;
   }
-  if (event.kind.startsWith("create") && "handleId" in event) return event.handleId;
+  if ((event.kind.startsWith("create") || event.kind === "getBindGroupLayout") && "handleId" in event)
+    return event.handleId;
   return void 0;
 }
 function resourceKind(event) {
@@ -6107,6 +6150,8 @@ function resourceKind(event) {
       return "buffer";
     case "createTexture":
       return "texture";
+    case "createQuerySet":
+      return "query-set";
     case "createTextureView":
       return "texture-view";
     case "createSampler":
@@ -6118,6 +6163,7 @@ function resourceKind(event) {
       return "pipeline";
     case "createBindGroup":
     case "createBindGroupLayout":
+    case "getBindGroupLayout":
     case "createPipelineLayout":
       return "binding";
     case "createCommandEncoder":
@@ -6263,6 +6309,7 @@ function _collectFrameReferencedHandleIds(events) {
           if (vhId !== void 0) refs.add(vhId);
         }
         if (we.depthStencilViewHandleId !== void 0) refs.add(we.depthStencilViewHandleId);
+        if (we.occlusionQuerySetHandleId !== void 0) refs.add(we.occlusionQuerySetHandleId);
         break;
       }
       case "beginComputePass": {
@@ -6317,6 +6364,7 @@ function _collectFrameReferencedHandleIds(events) {
         break;
       }
       case "createBindGroup":
+      case "getBindGroupLayout":
       case "createPipelineLayout":
       case "createRenderPipeline":
       case "createComputePipeline":
@@ -6326,8 +6374,27 @@ function _collectFrameReferencedHandleIds(events) {
       }
       case "destroyBuffer":
       case "destroyTexture":
+      case "destroyQuerySet":
         refs.add(e.handleId);
         break;
+      case "frameMark":
+      case "createBuffer":
+      case "createTexture":
+      case "createQuerySet":
+      case "createSampler":
+      case "createBindGroupLayout":
+      case "createShaderModule":
+      case "createCommandEncoder":
+        break;
+      case "resolveQuerySet":
+        refs.add(e.cmdHandleId);
+        refs.add(e.querySetHandleId);
+        refs.add(e.destinationHandleId);
+        break;
+      case "beginOcclusionQuery":
+      case "endOcclusionQuery":
+        refs.add(e.passHandleId);
+        break;
     }
   }
   return refs;
@@ -6361,8 +6428,11 @@ function _getCreateEventReferencedHandleIds(event) {
       const e = event;
       return [e.sourceHandleId];
     }
+    case "getBindGroupLayout":
+      return [event.pipelineHandleId];
     case "createBuffer":
     case "createTexture":
+    case "createQuerySet":
     case "createSampler":
     case "createBindGroupLayout":
     case "createShaderModule":
@@ -6608,18 +6678,21 @@ function getHandleId(s, handle, kind) {
 }
 
 // src/recorder/shader.ts
+function recordShaderModule(debugInst, result, desc) {
+  if (!result.ok) return result;
+  const hId = debugInst.pushExternalCreateEvent(result.value, "shaderModule", {
+    kind: "createShaderModule",
+    handleId: "",
+    wgslCode: desc.code
+  });
+  debugInst.registerShaderModule(result.value, hId);
+  return result;
+}
 function wrapCreateShaderModule(originalFn, debugInst) {
   return async function wrappedCreateShaderModule(device, desc) {
     const realDevice = device._realDevice ?? device;
     const result = await originalFn(realDevice, desc);
-    if (!result.ok) return result;
-    const hId = debugInst.pushExternalCreateEvent(result.value, "shaderModule", {
-      kind: "createShaderModule",
-      handleId: "",
-      wgslCode: desc.code
-    });
-    debugInst.registerShaderModule(result.value, hId);
-    return result;
+    return recordShaderModule(debugInst, result, desc);
   };
 }
 
@@ -6782,10 +6855,15 @@ function createRenderPassProxy(s, realPass, passHId) {
       return realPass.executeBundles(bundles);
     },
     beginOcclusionQuery(queryIndex) {
-      return realPass.beginOcclusionQuery(queryIndex);
+      const result = realPass.beginOcclusionQuery(queryIndex);
+      if (result.ok)
+        pushEvent(s, { kind: "beginOcclusionQuery", passHandleId: passHId, queryIndex });
+      return result;
     },
     endOcclusionQuery() {
-      return realPass.endOcclusionQuery();
+      const result = realPass.endOcclusionQuery();
+      if (result.ok) pushEvent(s, { kind: "endOcclusionQuery", passHandleId: passHId });
+      return result;
     },
     end() {
       pushEvent(s, { kind: "endRenderPass", passHandleId: passHId });
@@ -6875,13 +6953,19 @@ function createCommandEncoderProxy(s, realEnc, cmdHId) {
             (attachment) => attachment === null || attachment === void 0 ? attachment : { ...attachment }
           ),
           ...desc.depthStencilAttachment === void 0 ? {} : { depthStencilAttachment: { ...desc.depthStencilAttachment } },
-          ...desc.occlusionQuerySet === void 0 ? {} : { occlusionQuerySet: desc.occlusionQuerySet },
           ...desc.timestampWrites === void 0 ? {} : { timestampWrites: desc.timestampWrites },
           ...desc.maxDrawCount === void 0 ? {} : { maxDrawCount: desc.maxDrawCount }
         },
         colorAttachmentViewHandleIds,
         colorAttachmentResolveTargetHandleIds,
-        depthStencilViewHandleId
+        depthStencilViewHandleId,
+        ...desc.occlusionQuerySet === void 0 ? {} : {
+          occlusionQuerySetHandleId: getHandleId(
+            s,
+            desc.occlusionQuerySet,
+            "querySet"
+          )
+        }
       });
       const realPass = realEnc.beginRenderPass(desc);
       return createRenderPassProxy(s, realPass, passHId);
@@ -7021,13 +7105,25 @@ function createCommandEncoderProxy(s, realEnc, cmdHId) {
       realEnc.clearBuffer(buffer, offset, size);
     },
     resolveQuerySet(querySet, firstQuery, queryCount, destination, destinationOffset) {
-      return realEnc.resolveQuerySet(
+      const result = realEnc.resolveQuerySet(
         querySet,
         firstQuery,
         queryCount,
         destination,
         destinationOffset
       );
+      if (result.ok) {
+        pushEvent(s, {
+          kind: "resolveQuerySet",
+          cmdHandleId: cmdHId,
+          querySetHandleId: getHandleId(s, querySet, "querySet"),
+          firstQuery,
+          queryCount,
+          destinationHandleId: getHandleId(s, destination, "buffer"),
+          destinationOffset
+        });
+      }
+      return result;
     },
     pushDebugGroup(groupLabel) {
       pushEvent(s, { kind: "pushDebugGroup", cmdHandleId: cmdHId, groupLabel });
@@ -7052,6 +7148,29 @@ function createCommandEncoderProxy(s, realEnc, cmdHId) {
   };
 }
 
+// src/recorder/pipeline.ts
+function wrapPipeline(state, pipeline, pipelineHandleId) {
+  const operation = pipeline.getBindGroupLayout;
+  if (operation === void 0) return pipeline;
+  const getLayout = operation.bind(pipeline);
+  Object.defineProperty(pipeline, "getBindGroupLayout", {
+    configurable: true,
+    value: (index) => {
+      const layout = getLayout(index);
+      const event = {
+        kind: "getBindGroupLayout",
+        handleId: "",
+        pipelineHandleId,
+        index
+      };
+      registerHandle(state, layout, "bindGroupLayout", event);
+      pushEvent(state, event);
+      return layout;
+    }
+  });
+  return pipeline;
+}
+
 // src/recorder/queue.ts
 function createQueueProxy(s, realQueue) {
   return {
@@ -7381,9 +7500,9 @@ function createDeviceProxy(s, realDevice) {
         vertexShaderModuleHandleId,
         fragmentShaderModuleHandleId
       };
-      registerHandle(s, res.value, "renderPipeline", event);
+      const pipelineId = registerHandle(s, res.value, "renderPipeline", event);
       pushEvent(s, event);
-      return res;
+      return ok(wrapPipeline(s, res.value, pipelineId));
     },
     createComputePipeline(desc) {
       const res = realDevice.createComputePipeline(desc);
@@ -7406,12 +7525,25 @@ function createDeviceProxy(s, realDevice) {
         layoutHandleId: layoutId,
         computeShaderModuleHandleId
       };
-      registerHandle(s, res.value, "computePipeline", event);
+      const pipelineId = registerHandle(s, res.value, "computePipeline", event);
       pushEvent(s, event);
-      return res;
+      return ok(wrapPipeline(s, res.value, pipelineId));
     },
     createQuerySet(desc) {
-      return realDevice.createQuerySet(desc);
+      const res = realDevice.createQuerySet(desc);
+      if (!res.ok) return res;
+      const event = {
+        kind: "createQuerySet",
+        handleId: "",
+        desc: {
+          ...desc.label === void 0 ? {} : { label: desc.label },
+          type: desc.type ?? "occlusion",
+          count: desc.count ?? 0
+        }
+      };
+      registerHandle(s, res.value, "querySet", event);
+      pushEvent(s, event);
+      return res;
     },
     destroyBuffer(buf) {
       const hId = s.handleMap.get(buf);
@@ -7427,7 +7559,16 @@ function createDeviceProxy(s, realDevice) {
       return res;
     },
     destroyQuerySet(querySet) {
-      return realDevice.destroyQuerySet(querySet);
+      const hId = s.handleMap.get(querySet);
+      const res = realDevice.destroyQuerySet(querySet);
+      if (!res.ok) return res;
+      if (hId !== void 0) {
+        if (!retainsCaptureBootstrap(s) && !s.snapshotSeededHandles.has(hId) && !hasBootstrapDependency(s, hId)) {
+          s.bootstrapCreates.delete(hId);
+        }
+        pushEvent(s, { kind: "destroyQuerySet", handleId: hId });
+      }
+      return res;
     },
     destroyTexture(tex) {
       const hId = s.handleMap.get(tex);
@@ -8180,15 +8321,46 @@ function wrap(instance) {
 function createRecorderProxy(backend) {
   const recorder = wrap(backend.rhi);
   const wrappedCreateShaderModule = wrapCreateShaderModule(backend.createShaderModule, recorder);
+  const originalCreateShaderModuleImmediate = backend.createShaderModuleImmediate;
+  const wrappedCreateShaderModuleImmediate = originalCreateShaderModuleImmediate === void 0 ? void 0 : (device, desc) => {
+    const realDevice = device._realDevice ?? device;
+    const result = originalCreateShaderModuleImmediate(realDevice, desc);
+    if (!result.ok) return result;
+    const hId = recorder.pushExternalCreateEvent(result.value, "shaderModule", {
+      kind: "createShaderModule",
+      handleId: "",
+      wgslCode: desc.code
+    });
+    recorder.registerShaderModule(result.value, hId);
+    return result;
+  };
   const acquireCanvasContext = backend.rhi.acquireCanvasContext;
   const rhi = {
     requestAdapter: recorder.requestAdapter.bind(recorder),
     createShaderModule: wrappedCreateShaderModule,
-    ...acquireCanvasContext === void 0 ? {} : { acquireCanvasContext: acquireCanvasContext.bind(backend.rhi) }
+    ...wrappedCreateShaderModuleImmediate === void 0 ? {} : { createShaderModuleImmediate: wrappedCreateShaderModuleImmediate },
+    ...acquireCanvasContext === void 0 ? {} : {
+      acquireCanvasContext(canvas) {
+        const result = acquireCanvasContext.call(backend.rhi, canvas);
+        if (!result.ok) return result;
+        const context = result.value;
+        return ok({
+          ...context,
+          configure(configuration) {
+            const device = configuration.device._realDevice;
+            return context.configure({
+              ...configuration,
+              ...device === void 0 ? {} : { device }
+            });
+          }
+        });
+      }
+    }
   };
   const wrappedBackend = {
     rhi,
     createShaderModule: wrappedCreateShaderModule,
+    ...wrappedCreateShaderModuleImmediate === void 0 ? {} : { createShaderModuleImmediate: wrappedCreateShaderModuleImmediate },
     unwrapDeviceForSurface(device) {
       const raw = device._realDevice;
       if (raw !== void 0) return ok(raw);
@@ -8619,10 +8791,20 @@ async function executeEvent(context, event, eventIndex) {
             kind: "texture"
           }
         );
+      case "createQuerySet":
+        return createResource(
+          context,
+          eventIndex,
+          event,
+          context.device.createQuerySet(event.desc),
+          { kind: "query-set" }
+        );
       case "destroyBuffer":
         return destroyResource(context, eventIndex, event, "buffer");
       case "destroyTexture":
         return destroyResource(context, eventIndex, event, "texture");
+      case "destroyQuerySet":
+        return destroyQuerySet(context, event, eventIndex);
       case "createTextureView": {
         const texture = requireResource(
           context,
@@ -8659,6 +8841,25 @@ async function executeEvent(context, event, eventIndex) {
           context.device.createBindGroupLayout(event.desc),
           { kind: "binding", role: "bind-group-layout" }
         );
+      case "getBindGroupLayout": {
+        const pipeline = requireReplayResource(
+          context,
+          event.pipelineHandleId,
+          "pipeline",
+          eventIndex,
+          event.kind
+        );
+        if (!pipeline.ok) return pipeline;
+        return createResource(
+          context,
+          eventIndex,
+          event,
+          ok(
+            pipeline.value.value.getBindGroupLayout(event.index)
+          ),
+          { kind: "binding", role: "bind-group-layout" }
+        );
+      }
       case "createBindGroup":
         return createBindGroup(context, event, eventIndex);
       case "createPipelineLayout":
@@ -8690,6 +8891,18 @@ async function executeEvent(context, event, eventIndex) {
         return beginRenderPass(context, event, eventIndex);
       case "beginComputePass":
         return beginComputePass(context, event, eventIndex);
+      case "resolveQuerySet":
+        return resolveQuerySet(context, event, eventIndex);
+      case "beginOcclusionQuery":
+        return passCall(context, event, eventIndex, "render-pass", (pass) => {
+          const result = pass.beginOcclusionQuery(event.queryIndex);
+          return result.ok ? ok(void 0) : eventFailure(eventIndex, event, "encode", result.error);
+        });
+      case "endOcclusionQuery":
+        return passCall(context, event, eventIndex, "render-pass", (pass) => {
+          const result = pass.endOcclusionQuery();
+          return result.ok ? ok(void 0) : eventFailure(eventIndex, event, "encode", result.error);
+        });
       case "copyBufferToBuffer":
         return copyBufferToBuffer(context, event, eventIndex);
       case "copyBufferToTexture":
@@ -8920,6 +9133,50 @@ function destroyResource(context, eventIndex, event, kind) {
   context.table.delete(event.handleId);
   return ok(void 0);
 }
+function destroyQuerySet(context, event, eventIndex) {
+  const entry = context.table.get(event.handleId);
+  if (entry?.resource.kind !== "query-set")
+    return missingResource(eventIndex, event, event.handleId, "query-set");
+  const result = context.device.destroyQuerySet(entry.resource.value);
+  if (!result.ok) return eventFailure(eventIndex, event, "create", result.error);
+  context.table.delete(event.handleId);
+  return ok(void 0);
+}
+function resolveQuerySet(context, event, eventIndex) {
+  const encoder = requireResource(
+    context,
+    event.cmdHandleId,
+    "encoder",
+    eventIndex,
+    event.kind,
+    "command"
+  );
+  const querySet = requireResource(
+    context,
+    event.querySetHandleId,
+    "query-set",
+    eventIndex,
+    event.kind
+  );
+  const destination = requireResource(
+    context,
+    event.destinationHandleId,
+    "buffer",
+    eventIndex,
+    event.kind
+  );
+  if (!encoder.ok) return encoder;
+  if (!querySet.ok) return querySet;
+  if (!destination.ok) return destination;
+  const result = encoder.value.resolveQuerySet(
+    querySet.value,
+    event.firstQuery,
+    event.queryCount,
+    destination.value,
+    event.destinationOffset
+  );
+  return result.ok ? ok(void 0) : eventFailure(eventIndex, event, "encode", result.error);
+}
 async function createShaderModule(context, event, eventIndex) {
   const result = await context.createShaderModule(context.device, { code: event.wgslCode });
   return createResource(context, eventIndex, event, result, { kind: "shader-module" });
@@ -9145,6 +9402,10 @@ function beginRenderPass(context, event, eventIndex) {
     };
   });
   const depth = event.depthStencilViewHandleId === void 0 ? void 0 : context.table.get(event.depthStencilViewHandleId)?.resource;
+  const querySet = event.occlusionQuerySetHandleId === void 0 ? void 0 : context.table.get(event.occlusionQuerySetHandleId)?.resource;
+  if (event.occlusionQuerySetHandleId !== void 0 && querySet?.kind !== "query-set") {
+    return missingResource(eventIndex, event, event.occlusionQuerySetHandleId, "query-set");
+  }
   const descriptor = {
     ...event.desc,
     colorAttachments: colors,
@@ -9153,7 +9414,8 @@ function beginRenderPass(context, event, eventIndex) {
         ...event.desc.depthStencilAttachment,
         view: depth.value
       }
-    } : {}
+    } : {},
+    ...querySet?.kind === "query-set" ? { occlusionQuerySet: querySet.value } : {}
   };
   const pass = encoder.value.beginRenderPass(descriptor);
   return context.table.set(
@@ -9353,7 +9615,7 @@ async function readReplayResource(device, table, resourceId, subresource, create
   });
 }
 function resolveTextureViewSubresource(view, source, requested) {
-  if (requested === void 0 || isBufferRange(requested)) return ok(requested);
+  if (isBufferRange(requested)) return ok(requested);
   const sourceDescriptor = recordField(source.descriptor, "desc");
   const sourceSize = textureSize(sourceDescriptor?.size);
   const sourceMipCount = numberField(sourceDescriptor, "mipLevelCount") ?? 1;
@@ -9362,15 +9624,16 @@ function resolveTextureViewSubresource(view, source, requested) {
   const baseArrayLayer = numberField(viewDescriptor, "baseArrayLayer") ?? 0;
   const mipLevelCount = numberField(viewDescriptor, "mipLevelCount") ?? sourceMipCount - baseMipLevel;
   const arrayLayerCount = numberField(viewDescriptor, "arrayLayerCount") ?? sourceSize.depthOrArrayLayers - baseArrayLayer;
-  const localMipLevel = requested.mipLevel ?? 0;
-  const localArrayLayer = requested.arrayLayer ?? 0;
+  const localMipLevel = requested?.mipLevel ?? 0;
+  const localArrayLayer = requested?.arrayLayer ?? 0;
   if (!validIndex(baseMipLevel, sourceMipCount + 1) || !validIndex(baseArrayLayer, sourceSize.depthOrArrayLayers + 1) || !validIndex(localMipLevel, mipLevelCount) || !validIndex(localArrayLayer, arrayLayerCount) || baseMipLevel + mipLevelCount > sourceMipCount || baseArrayLayer + arrayLayerCount > sourceSize.depthOrArrayLayers) {
     return readbackFailure("texture view subresource is outside the recorded view extent");
   }
   return ok({
     ...requested,
     mipLevel: baseMipLevel + localMipLevel,
-    arrayLayer: baseArrayLayer + localArrayLayer
+    arrayLayer: baseArrayLayer + localArrayLayer,
+    aspect: requested?.aspect ?? (viewDescriptor?.aspect === "depth-only" || viewDescriptor?.aspect === "stencil-only" ? viewDescriptor.aspect : "all")
   });
 }
 async function readBuffer(device, entry, resourceId, subresource) {
@@ -9877,6 +10140,10 @@ var ResourceTable = class {
         const result = this.device.destroyTexture(entry.resource.value);
         if (!result.ok && firstFailure === void 0)
           firstFailure = resourceDisposeFailure(entry.resourceId, result.error.code);
+      } else if (entry.resource.kind === "query-set") {
+        const result = this.device.destroyQuerySet(entry.resource.value);
+        if (!result.ok && firstFailure === void 0)
+          firstFailure = resourceDisposeFailure(entry.resourceId, result.error.code);
       }
     }
     return firstFailure ?? ok(void 0);
@@ -10009,6 +10276,42 @@ async function openReplay(tape, backend) {
         backend.createShaderModule
       );
     },
+    async readResourceAtWork(resourceId, workIndex, subresource, signal) {
+      if (disposed) return positionError(workIndex, index.works.length);
+      if (signal?.aborted) {
+        return err(
+          createRhiDebugError("readback-failed", {
+            stage: "readback",
+            cause: "readback was aborted"
+          })
+        );
+      }
+      const work = index.works[workIndex];
+      if (work === void 0 || model.works[workIndex] === void 0) {
+        return positionError(workIndex, index.works.length);
+      }
+      const cleared = await reset();
+      if (!cleared.ok) return cleared;
+      const bootstrapped = await prepare();
+      if (!bootstrapped.ok) return bootstrapped;
+      const replayed = await replayThroughWork(context, index, work, signal);
+      if (!replayed.ok) return replayed;
+      const read = await readReplayResource(
+        backend.device,
+        table,
+        resourceId,
+        subresource,
+        backend.createShaderModule
+      );
+      if (!read.ok) return read;
+      return ok({
+        ...read.value,
+        provenance: {
+          ...read.value.provenance,
+          selectedWorkIndex: work.workIndex
+        }
+      });
+    },
     async dispose() {
       if (disposed) return ok(void 0);
       const result = table.dispose();
@@ -10110,7 +10413,8 @@ function requiredReplayCapabilities(tape) {
 }
 async function executeBootstrapResource(context, resource, bootstrapIndex) {
   const event = JSON.parse(JSON.stringify(resource.create));
-  const result = await executeEvent(context, event, -bootstrapIndex - 1);
+  const replayEvent = event.kind === "createBuffer" && resource.initialData.length > 0 ? { ...event, desc: { ...event.desc, mappedAtCreation: true } } : event;
+  const result = await executeEvent(context, replayEvent, -bootstrapIndex - 1);
   return result;
 }
 async function seedBootstrapResource(context, resource, bootstrapIndex) {
@@ -10128,25 +10432,41 @@ async function seedBootstrapResource(context, resource, bootstrapIndex) {
       "bootstrap initialData requires a buffer or color texture resource"
     );
   }
-  for (const slice of resource.initialData) {
-    const blob2 = context.tape.blobs.find((candidate) => candidate.hash === slice.hash);
-    if (blob2 === void 0) {
-      return eventFailure(-bootstrapIndex - 1, event, "lookup", `blob ${slice.hash} is missing`);
-    }
-    const end = slice.byteOffset + slice.byteLength;
-    if (slice.byteOffset < 0 || slice.byteLength < 0 || end > blob2.bytes.byteLength) {
-      return eventFailure(
-        -bootstrapIndex - 1,
-        event,
-        "lookup",
-        `blob ${slice.hash} does not contain initialData slice [${slice.byteOffset}, ${end})`
-      );
-    }
-    const bytes = blob2.bytes.slice(slice.byteOffset, slice.byteOffset + slice.byteLength);
-    const written = context.queue.writeBuffer(entry.resource.value, 0, bytes);
-    if (!written.ok) {
-      return eventFailure(-bootstrapIndex - 1, event, "write", written.error);
+  const mapped = entry.resource.value;
+  if (typeof mapped.getMappedRange !== "function" || typeof mapped.unmap !== "function") {
+    if (context.device.caps.backendKind === "null") return ok(void 0);
+    return eventFailure(
+      -bootstrapIndex - 1,
+      event,
+      "write",
+      "bootstrap buffer mapping is unavailable on the replay backend"
+    );
+  }
+  try {
+    const range = mapped.getMappedRange();
+    if (!range.ok) return eventFailure(-bootstrapIndex - 1, event, "write", range.error);
+    const target = new Uint8Array(range.value);
+    for (const slice of resource.initialData) {
+      const blob2 = context.tape.blobs.find((candidate) => candidate.hash === slice.hash);
+      if (blob2 === void 0) {
+        return eventFailure(-bootstrapIndex - 1, event, "lookup", `blob ${slice.hash} is missing`);
+      }
+      const end = slice.byteOffset + slice.byteLength;
+      if (slice.byteOffset < 0 || slice.byteLength < 0 || end > blob2.bytes.byteLength) {
+        return eventFailure(
+          -bootstrapIndex - 1,
+          event,
+          "lookup",
+          `blob ${slice.hash} does not contain initialData slice [${slice.byteOffset}, ${end})`
+        );
+      }
+      if (slice.byteLength > target.byteLength) {
+        return eventFailure(-bootstrapIndex - 1, event, "write", "initialData exceeds buffer size");
+      }
+      target.set(blob2.bytes.subarray(slice.byteOffset, end));
     }
+  } finally {
+    mapped.unmap();
   }
   return ok(void 0);
 }
@@ -10245,12 +10565,8 @@ async function finalizeWorkPass(context, index, work) {
       `pass ${begin.passHandleId} is not open`
     );
   }
-  try {
-    entry.resource.value.end();
-  } catch (cause) {
-    return eventFailure(pass.endEventIndex ?? work.eventIndex, begin, "encode", cause);
-  }
-  context.table.delete(begin.passHandleId);
+  const closed = closeReplayPass(context, entry, begin, pass, work.eventIndex);
+  if (!closed.ok) return closed;
   const finishEventIndex = findNextEvent(
     context.tape.events,
     pass.beginEventIndex,
@@ -10266,6 +10582,13 @@ async function finalizeWorkPass(context, index, work) {
       `encoder ${begin.cmdHandleId} is not available`
     );
   }
+  const closure = await replayCommandClosure(
+    context,
+    begin.cmdHandleId,
+    (pass.endEventIndex ?? work.eventIndex) + 1,
+    finishEventIndex ?? context.tape.events.length
+  );
+  if (!closure.ok) return closure;
   const finished = encoder.resource.value.finish();
   const finishEvent = context.tape.events[finishEventIndex ?? work.eventIndex] ?? begin;
   if (!finished.ok)
@@ -10293,6 +10616,95 @@ async function finalizeWorkPass(context, index, work) {
   await context.queue.onSubmittedWorkDone();
   return ok(void 0);
 }
+function closeReplayPass(context, entry, begin, pass, selectedEventIndex) {
+  const activeQuery = activeOcclusionQuery(
+    context.tape.events,
+    begin.kind === "beginRenderPass" ? begin.passHandleId : void 0,
+    pass.beginEventIndex,
+    selectedEventIndex
+  );
+  if (!activeQuery.ok) return activeQuery;
+  try {
+    if (activeQuery.value !== void 0) {
+      if (entry.resource.role !== "render-pass") {
+        return eventFailure(
+          activeQuery.value.eventIndex,
+          activeQuery.value.event,
+          "lookup",
+          "an active occlusion query belongs to a non-render pass"
+        );
+      }
+      const endedQuery = entry.resource.value.endOcclusionQuery();
+      if (!endedQuery.ok) {
+        return eventFailure(
+          activeQuery.value.eventIndex,
+          activeQuery.value.event,
+          "encode",
+          endedQuery.error
+        );
+      }
+    }
+    entry.resource.value.end();
+  } catch (cause) {
+    return eventFailure(pass.endEventIndex ?? selectedEventIndex, begin, "encode", cause);
+  }
+  context.table.delete(begin.passHandleId);
+  return ok(void 0);
+}
+async function replayCommandClosure(context, cmdHandleId, start, end) {
+  for (let eventIndex = start; eventIndex < end; eventIndex++) {
+    const event = context.tape.events[eventIndex];
+    if (event === void 0 || !isCommandClosureEvent(event)) continue;
+    if (event.cmdHandleId !== cmdHandleId) continue;
+    const result = await executeEvent(context, event, eventIndex);
+    if (!result.ok) return result;
+  }
+  return ok(void 0);
+}
+function activeOcclusionQuery(events, passHandleId, beginEventIndex, selectedEventIndex) {
+  if (passHandleId === void 0) return ok(void 0);
+  let active;
+  for (let eventIndex = beginEventIndex + 1; eventIndex <= selectedEventIndex; eventIndex++) {
+    const event = events[eventIndex];
+    if (event === void 0 || !("passHandleId" in event) || event.passHandleId !== passHandleId)
+      continue;
+    if (event.kind === "beginOcclusionQuery") {
+      if (active !== void 0) {
+        return eventFailure(
+          eventIndex,
+          event,
+          "encode",
+          "an occlusion query is already active for this render pass"
+        );
+      }
+      active = { eventIndex, event };
+    } else if (event.kind === "endOcclusionQuery") {
+      if (active === void 0) {
+        return eventFailure(
+          eventIndex,
+          event,
+          "encode",
+          "an occlusion query ended without a matching begin"
+        );
+      }
+      active = void 0;
+    }
+  }
+  return ok(active);
+}
+function isCommandClosureEvent(event) {
+  switch (event.kind) {
+    case "resolveQuerySet":
+    case "copyBufferToBuffer":
+    case "copyBufferToTexture":
+    case "copyTextureToBuffer":
+    case "copyTextureToTexture":
+    case "clearBuffer":
+      return true;
+    default:
+      return false;
+  }
+}
 function findNextEvent(events, start, kind, commandId) {
   for (let index = start + 1; index < events.length; index++) {
     const event = events[index];