@forgeax/engine-rhi-debug 0.1.6 → 0.1.7

package/dist/index.mjs

@@ -4718,30 +4718,254 @@ function computeTextureLayout(format, width, height, layerCount, mipLevelCount)
 }
 
 // src/frame-model.ts
+function jsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return value;
+  if (value === void 0) return null;
+  if (Array.isArray(value)) return value.map(jsonValue);
+  if (ArrayBuffer.isView(value))
+    return Array.from(value, jsonValue);
+  if (typeof value === "object") {
+    const output = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (child !== void 0) output[key] = jsonValue(child);
+    }
+    return output;
+  }
+  return String(value);
+}
+function eventDescriptor(event) {
+  return jsonValue(event);
+}
+function workPipeline(pipelineId, pipelineEvents, shaderEvents) {
+  if (pipelineId === void 0)
+    return { status: "unavailable", shaders: [], reason: "pipeline-not-bound" };
+  const event = pipelineEvents.get(pipelineId);
+  if (event === void 0)
+    return { status: "unavailable", shaders: [], reason: "descriptor-unavailable" };
+  const shaders = [];
+  const shaderRefs = event.kind === "createRenderPipeline" ? [
+    ["vertex", event.vertexShaderModuleHandleId, event.desc.vertex?.entryPoint],
+    ["fragment", event.fragmentShaderModuleHandleId, event.desc.fragment?.entryPoint]
+  ] : event.kind === "createComputePipeline" ? [["compute", event.computeShaderModuleHandleId, event.desc.compute.entryPoint]] : [];
+  for (const [stage, moduleId, entryPoint] of shaderRefs) {
+    if (typeof moduleId !== "string") continue;
+    const shader = shaderEvents.get(moduleId);
+    shaders.push({
+      stage,
+      moduleHandleId: moduleId,
+      entryPoint: typeof entryPoint === "string" ? entryPoint : null,
+      source: shader?.kind === "createShaderModule" ? shader.wgslCode : null
+    });
+  }
+  return {
+    status: "available",
+    pipelineHandleId: pipelineId,
+    kind: event.kind === "createRenderPipeline" ? "render" : "compute",
+    descriptor: eventDescriptor(event),
+    shaders
+  };
+}
 function buildFrameModel(tape) {
   const index = buildTapeIndex(tape);
-  const works = index.works;
-  return {
-    tree: [],
-    draws: [],
-    meta: {
-      totalDraws: works.length,
-      totalPasses: index.passes.length,
-      hasCompute: works.some((work) => work.kind.startsWith("dispatch"))
-    },
-    commands: tape.events.map((event, eventIndex) => ({
-      passIdx: index.passIndexByEvent[eventIndex] ?? -1,
-      eventIdx: eventIndex,
-      isDraw: isWorkEvent(event.kind),
+  const events = tape.events;
+  const passCommandIndices = index.passes.map(() => []);
+  const commands = [];
+  const groupPath = [];
+  const currentPassByEvent = index.passIndexByEvent;
+  const passAttachmentByIndex = /* @__PURE__ */ new Map();
+  for (const pass of index.passes) {
+    passAttachmentByIndex.set(pass.passIndex, {
+      passIndex: pass.passIndex,
+      kind: pass.kind,
+      beginEventIndex: pass.beginEventIndex,
+      endEventIndex: pass.endEventIndex ?? null,
+      workIndices: pass.workIndices,
+      commandIndices: [],
+      colorAttachmentViewHandleIds: [],
+      depthStencilViewHandleId: null
+    });
+    const begin = events[pass.beginEventIndex];
+    if (begin?.kind === "beginRenderPass") {
+      const attachment = passAttachmentByIndex.get(pass.passIndex);
+      if (attachment !== void 0) {
+        attachment.colorAttachmentViewHandleIds = begin.colorAttachmentViewHandleIds.filter(
+          (id) => typeof id === "string"
+        );
+        attachment.depthStencilViewHandleId = begin.depthStencilViewHandleId ?? null;
+      }
+    }
+  }
+  for (const [eventIndex, event] of events.entries()) {
+    const passIndex = currentPassByEvent[eventIndex] ?? -1;
+    const isPush = event.kind === "pushDebugGroup" || event.kind === "passPushDebugGroup";
+    const isPop = event.kind === "popDebugGroup" || event.kind === "passPopDebugGroup";
+    const group = isPush ? [...groupPath, event.groupLabel] : [...groupPath];
+    const marker = event.kind === "insertDebugMarker" || event.kind === "passInsertDebugMarker" ? event.markerLabel : void 0;
+    const commandIndex = commands.length;
+    commands.push({
+      eventIndex,
+      passIndex,
       kind: event.kind,
-      groupLabel: void 0,
-      markerLabel: void 0
-    })),
-    resources: /* @__PURE__ */ new Map(),
-    resourceLifecycle: buildResourceLifecycle(tape.events),
-    works,
-    passes: index.passes,
-    resourceEntries: index.resources
+      category: EVENT_SEMANTICS[event.kind].category,
+      isWork: isWorkEvent(event.kind),
+      params: eventDescriptor(event),
+      group,
+      ...marker === void 0 ? {} : { marker }
+    });
+    if (passIndex >= 0) passCommandIndices[passIndex]?.push(commandIndex);
+    if (isPush) groupPath.push(event.groupLabel);
+    if (isPop) groupPath.pop();
+  }
+  const pipelineEvents = /* @__PURE__ */ new Map();
+  const shaderEvents = /* @__PURE__ */ new Map();
+  const bindGroups = /* @__PURE__ */ new Map();
+  const resourceRecords = /* @__PURE__ */ new Map();
+  const workByEvent = /* @__PURE__ */ new Map();
+  for (const work of index.works) workByEvent.set(work.eventIndex, work.workIndex);
+  for (const bootstrap of tape.bootstrap) {
+    const create = bootstrap.create;
+    if (create.kind === "createRenderPipeline" || create.kind === "createComputePipeline")
+      pipelineEvents.set(create.handleId, create);
+    if (create.kind === "createShaderModule") shaderEvents.set(create.handleId, create);
+    if (create.kind === "createBindGroup") bindGroups.set(create.handleId, create);
+    resourceRecords.set(bootstrap.handleId, {
+      resourceId: bootstrap.handleId,
+      kind: bootstrap.kind,
+      origin: "bootstrap",
+      createEventIndex: null,
+      destroyEventIndex: null,
+      descriptor: jsonValue(bootstrap.create),
+      consumers: [],
+      lifecycle: { state: "unavailable", byteEstimate: null }
+    });
+  }
+  for (const [eventIndex, event] of events.entries()) {
+    if (event.kind === "createRenderPipeline" || event.kind === "createComputePipeline")
+      pipelineEvents.set(event.handleId, event);
+    if (event.kind === "createShaderModule") shaderEvents.set(event.handleId, event);
+    if (event.kind === "createBindGroup") bindGroups.set(event.handleId, event);
+    const kind = resourceKindForEvent(event.kind);
+    const handleId = kind === void 0 ? void 0 : event.kind === "createTextureView" ? event.resultHandleId : event.kind === "createCommandEncoder" ? event.cmdHandleId : "handleId" in event ? event.handleId : void 0;
+    if (kind !== void 0 && handleId !== void 0) {
+      resourceRecords.set(handleId, {
+        resourceId: handleId,
+        kind,
+        origin: "frame",
+        createEventIndex: eventIndex,
+        destroyEventIndex: null,
+        descriptor: eventDescriptor(event),
+        consumers: [],
+        lifecycle: { state: "unavailable", byteEstimate: null }
+      });
+    }
+  }
+  const lifecycle = buildResourceLifecycle(events);
+  for (const record of lifecycle.resources) {
+    const resource = resourceRecords.get(record.handleId);
+    if (resource === void 0) continue;
+    resourceRecords.set(record.handleId, {
+      ...resource,
+      destroyEventIndex: record.destroyedEventIndex ?? null,
+      lifecycle: { state: record.state, byteEstimate: record.byteEstimate }
+    });
+  }
+  for (const [eventIndex, event] of events.entries()) {
+    const workIndex = workByEvent.get(eventIndex) ?? null;
+    for (const resourceId of EVENT_SEMANTICS[event.kind].read(event)) {
+      const resource = resourceRecords.get(resourceId);
+      if (resource !== void 0)
+        resource.consumers = [...resource.consumers, { eventIndex, workIndex, access: "read" }];
+    }
+    for (const resourceId of EVENT_SEMANTICS[event.kind].written(event)) {
+      const resource = resourceRecords.get(resourceId);
+      if (resource !== void 0)
+        resource.consumers = [...resource.consumers, { eventIndex, workIndex, access: "write" }];
+    }
+  }
+  const works = [];
+  const currentPipeline = /* @__PURE__ */ new Map();
+  const currentVertexBuffers = /* @__PURE__ */ new Map();
+  const currentIndexBuffers = /* @__PURE__ */ new Map();
+  const currentBindGroups = /* @__PURE__ */ new Map();
+  const workByEventEntry = new Map(index.works.map((work) => [work.eventIndex, work]));
+  for (const [eventIndex, event] of events.entries()) {
+    if (event === void 0) continue;
+    const passHandleId = "passHandleId" in event ? event.passHandleId : "";
+    if (event.kind === "setPipeline" || event.kind === "setComputePipeline")
+      currentPipeline.set(passHandleId, event.pipelineHandleId);
+    if (event.kind === "setVertexBuffer") {
+      const buffers = currentVertexBuffers.get(passHandleId) ?? /* @__PURE__ */ new Map();
+      buffers.set(event.slot, {
+        bufferHandleId: event.bufferHandleId,
+        offset: event.offset ?? 0,
+        size: event.size ?? null
+      });
+      currentVertexBuffers.set(passHandleId, buffers);
+    }
+    if (event.kind === "setIndexBuffer")
+      currentIndexBuffers.set(passHandleId, {
+        bufferHandleId: event.bufferHandleId,
+        format: event.format,
+        offset: event.offset ?? 0,
+        size: event.size ?? null
+      });
+    if (event.kind === "setBindGroup") {
+      const groups2 = currentBindGroups.get(passHandleId) ?? /* @__PURE__ */ new Map();
+      groups2.set(event.index, event.bindGroupHandleId);
+      currentBindGroups.set(passHandleId, groups2);
+    }
+    if (!isWorkEvent(event.kind)) continue;
+    const work = workByEventEntry.get(eventIndex);
+    if (work === void 0) continue;
+    const pipelineId = currentPipeline.get(passHandleId);
+    const groups = currentBindGroups.get(passHandleId) ?? /* @__PURE__ */ new Map();
+    const bindings = [];
+    for (const [groupIndex, bindGroupId] of groups) {
+      const bindGroup = bindGroups.get(bindGroupId);
+      for (const [entryIndex, resourceId] of bindGroup?.resourceHandleIds.entries() ?? []) {
+        const entry = bindGroup?.entries[entryIndex];
+        bindings.push({
+          groupIndex,
+          binding: entry?.binding ?? entryIndex,
+          bindGroupId,
+          resourceId: resourceId ?? null,
+          resourceKind: entry?.resourceKind ?? null,
+          bufferOffset: entry?.bufferOffset ?? null,
+          bufferSize: entry?.bufferSize ?? null
+        });
+      }
+    }
+    const attachment = passAttachmentByIndex.get(work.passIndex);
+    works.push({
+      ...work,
+      commandIndex: commands.findIndex((command) => command.eventIndex === work.eventIndex),
+      drawCall: eventDescriptor(event),
+      pipeline: workPipeline(pipelineId, pipelineEvents, shaderEvents),
+      bindings,
+      vertexBuffers: [...currentVertexBuffers.get(passHandleId)?.entries() ?? []].map(
+        ([slot, buffer]) => ({ slot, ...buffer })
+      ),
+      indexBuffer: currentIndexBuffers.get(passHandleId) ?? null,
+      attachments: attachment === void 0 ? null : {
+        colorViewHandleIds: attachment.colorAttachmentViewHandleIds,
+        depthStencilViewHandleId: attachment.depthStencilViewHandleId
+      }
+    });
+  }
+  const passes = index.passes.map((pass) => ({
+    ...pass,
+    endEventIndex: pass.endEventIndex ?? null,
+    commandIndices: passCommandIndices[pass.passIndex] ?? [],
+    colorAttachmentViewHandleIds: passAttachmentByIndex.get(pass.passIndex)?.colorAttachmentViewHandleIds ?? [],
+    depthStencilViewHandleId: passAttachmentByIndex.get(pass.passIndex)?.depthStencilViewHandleId ?? null
+  }));
+  return {
+    commands,
+    passes,
+    resources: [...resourceRecords.values()],
+    resourceLifecycle: lifecycle,
+    works
   };
 }
 function asPositiveInteger(value) {
@@ -8128,6 +8352,31 @@ function attachRecorder(backend, options = {}) {
   };
   return ok(attachment);
 }
+
+// src/replay/device-request.ts
+var RECORDED_CAPABILITY_FEATURES = [
+  ["timestampQuery", "timestamp-query"],
+  ["textureCompressionBc", "texture-compression-bc"],
+  ["textureCompressionEtc2", "texture-compression-etc2"],
+  ["textureCompressionAstc", "texture-compression-astc"],
+  ["firstInstanceIndirect", "indirect-first-instance"],
+  ["float32Filterable", "float32-filterable"],
+  ["rg11b10ufloatRenderable", "rg11b10ufloat-renderable"]
+];
+function replayDeviceRequest(tape, adapterFeatures, adapterLimits) {
+  const requiredFeatures = RECORDED_CAPABILITY_FEATURES.filter(
+    ([capability, feature]) => tape.header.rhiCaps[capability] === true && adapterFeatures.has(feature)
+  ).map(([, feature]) => feature);
+  const limitEntries = Object.entries(adapterLimits).filter(
+    ([, value]) => Number.isFinite(value) && value >= 0
+  );
+  const request = {};
+  if (requiredFeatures.length > 0) request.requiredFeatures = requiredFeatures;
+  if (limitEntries.length > 0) {
+    request.requiredLimits = Object.fromEntries(limitEntries);
+  }
+  return request;
+}
 function eventRecord(event) {
   return JSON.parse(JSON.stringify(event));
 }
@@ -9059,18 +9308,59 @@ async function readReplayResource(device, table, resourceId, subresource, create
   const entry = table.get(resourceId);
   if (entry === void 0)
     return readbackFailure(`resource ${resourceId} is not present in the current generation`);
+  let result;
   if (entry.resource.kind === "texture-view") {
     const sourceId = stringField2(entry.descriptor, "sourceHandleId");
     const source = sourceId === void 0 ? void 0 : table.get(sourceId);
     if (source === void 0 || source.resource.kind !== "texture") {
       return readbackFailure(`texture view ${resourceId} has no readable source texture`);
     }
-    return readTexture(device, source, resourceId, subresource, createShaderModule2);
+    const sourceSubresource = resolveTextureViewSubresource(entry, source, subresource);
+    if (!sourceSubresource.ok) return sourceSubresource;
+    result = await readTexture(
+      device,
+      source,
+      resourceId,
+      sourceSubresource.value,
+      createShaderModule2
+    );
+  } else if (entry.resource.kind === "texture") {
+    result = await readTexture(device, entry, resourceId, subresource, createShaderModule2);
+  } else if (entry.resource.kind === "buffer") {
+    result = await readBuffer(device, entry, resourceId, subresource);
+  } else {
+    return readbackFailure(`resource ${resourceId} is not readable by the v7 core matrix`);
+  }
+  if (!result.ok) return result;
+  return ok({
+    ...result.value,
+    provenance: {
+      generation: table.generation,
+      resourceId,
+      subresource: subresource ?? null
+    }
+  });
+}
+function resolveTextureViewSubresource(view, source, requested) {
+  if (requested === void 0 || isBufferRange(requested)) return ok(requested);
+  const sourceDescriptor = recordField(source.descriptor, "desc");
+  const sourceSize = textureSize(sourceDescriptor?.size);
+  const sourceMipCount = numberField(sourceDescriptor, "mipLevelCount") ?? 1;
+  const viewDescriptor = recordField(view.descriptor, "desc");
+  const baseMipLevel = numberField(viewDescriptor, "baseMipLevel") ?? 0;
+  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;
+  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");
   }
-  if (entry.resource.kind === "texture")
-    return readTexture(device, entry, resourceId, subresource, createShaderModule2);
-  if (entry.resource.kind === "buffer") return readBuffer(device, entry, resourceId, subresource);
-  return readbackFailure(`resource ${resourceId} is not readable by the v7 core matrix`);
+  return ok({
+    ...requested,
+    mipLevel: baseMipLevel + localMipLevel,
+    arrayLayer: baseArrayLayer + localArrayLayer
+  });
 }
 async function readBuffer(device, entry, resourceId, subresource) {
   const size = numberField(recordField(entry.descriptor, "desc"), "size");
@@ -9118,18 +9408,15 @@ async function readTexture(device, entry, resourceId, subresource, createShaderM
   const width = Math.max(1, Math.floor(size.width / 2 ** mipLevel));
   const height = Math.max(1, Math.floor(size.height / 2 ** mipLevel));
   const requestedAspect = textureAspect(subresource);
-  if (format === "depth24plus" || format === "depth24plus-stencil8") {
-    if (format === "depth24plus-stencil8" && requestedAspect === "all") {
+  if (isDepthStencilTextureFormat(format)) {
+    if (requestedAspect === "all") {
       return readbackUnsupported(
         resourceId,
         format,
-        "depth24plus-stencil8 requires an explicit depth-only or stencil-only aspect"
+        `${format} requires an explicit depth-only or stencil-only aspect`
       );
     }
     if (requestedAspect === "stencil-only") {
-      if (format !== "depth24plus-stencil8") {
-        return readbackUnsupported(resourceId, format, "depth24plus has no stencil aspect");
-      }
       const bytes2 = await copyTextureBytes(
         device,
         entry.resource.value,
@@ -9147,6 +9434,24 @@ async function readTexture(device, entry, resourceId, subresource, createShaderM
       if (!bytes2.ok) return bytes2;
       return ok({ resourceId, kind: "texture", format, width, height, bytes: bytes2.value });
     }
+    if (format === "depth24plus-stencil8") {
+      return blitDepth24PlusTexture(
+        device,
+        entry.resource.value,
+        resourceId,
+        format,
+        width,
+        height,
+        mipLevel,
+        arrayLayer,
+        createShaderModule2
+      );
+    }
+  }
+  if (format === "depth24plus") {
+    if (requestedAspect === "stencil-only") {
+      return readbackUnsupported(resourceId, format, "depth24plus has no stencil aspect");
+    }
     return blitDepth24PlusTexture(
       device,
       entry.resource.value,
@@ -9354,7 +9659,10 @@ async function copyBufferBytes(device, source, sourceOffset, size) {
   let staging;
   let mapped;
   try {
-    const created = device.createBuffer({ size: Math.max(4, size), usage: COPY_DST_MAP_READ2 });
+    const alignedSourceOffset = sourceOffset - sourceOffset % 4;
+    const leadingBytes = sourceOffset - alignedSourceOffset;
+    const copySize = align4(leadingBytes + size);
+    const created = device.createBuffer({ size: Math.max(4, copySize), usage: COPY_DST_MAP_READ2 });
     if (!created.ok)
       return readbackFailure(`staging buffer creation failed: ${created.error.code}`);
     staging = created.value;
@@ -9362,7 +9670,7 @@ async function copyBufferBytes(device, source, sourceOffset, size) {
     if (!encoderResult.ok)
       return readbackFailure(`readback encoder creation failed: ${encoderResult.error.code}`);
     const encoder = encoderResult.value;
-    encoder.copyBufferToBuffer(source, sourceOffset, staging, 0, size);
+    encoder.copyBufferToBuffer(source, alignedSourceOffset, staging, 0, copySize);
     const finished = encoder.finish();
     if (!finished.ok)
       return readbackFailure(`readback encoder finish failed: ${finished.error.code}`);
@@ -9372,9 +9680,9 @@ async function copyBufferBytes(device, source, sourceOffset, size) {
     const mappedResult = await staging.mapAsync(GPU_MAP_MODE_READ);
     if (!mappedResult.ok) return readbackFailure(`readback map failed: ${mappedResult.error.code}`);
     mapped = mappedResult.value;
-    const range = mapped.getMappedRange(0, size);
+    const range = mapped.getMappedRange(0, copySize);
     if (!range.ok) return readbackFailure(`readback mapped range failed: ${range.error.code}`);
-    return ok(new Uint8Array(range.value).slice());
+    return ok(new Uint8Array(range.value).slice(leadingBytes, leadingBytes + size));
   } catch (cause) {
     return readbackFailure(`buffer readback failed: ${messageOf(cause)}`);
   } finally {
@@ -9489,6 +9797,9 @@ function validIndex(value, count) {
 function align256(value) {
   return Math.max(256, Math.ceil(value / 256) * 256);
 }
+function align4(value) {
+  return Math.ceil(value / 4) * 4;
+}
 function messageOf(cause) {
   return cause instanceof Error ? cause.message : String(cause);
 }
@@ -9584,6 +9895,7 @@ async function openReplay(tape, backend) {
   const capabilityFailure = checkCapabilities(tape, backend.device);
   if (capabilityFailure !== void 0) return err(capabilityFailure);
   const index = buildTapeIndex(tape);
+  const model = buildFrameModel(tape);
   const table = new ResourceTable(backend.device, 0);
   let disposed = false;
   let prepared = false;
@@ -9621,7 +9933,9 @@ async function openReplay(tape, backend) {
       if (disposed) return positionError(workIndex, index.works.length);
       if (signal?.aborted) return positionError(workIndex, index.works.length);
       const work = index.works[workIndex];
+      const modelWork = model.works[workIndex];
       if (work === void 0) return positionError(workIndex, index.works.length);
+      if (modelWork === void 0) return positionError(workIndex, index.works.length);
       const cleared = await reset();
       if (!cleared.ok) return cleared;
       const bootstrapped = await prepare();
@@ -9630,11 +9944,29 @@ async function openReplay(tape, backend) {
       if (!replayed.ok) return replayed;
       const attachment = fields?.includes("pixels") ? await readWorkAttachment(context, index, work) : void 0;
       if (attachment !== void 0 && !attachment.ok) return attachment;
-      return ok({
+      const selectedAttachment = attachment?.ok === true ? {
+        ...attachment.value,
+        provenance: {
+          ...attachment.value.provenance,
+          selectedWorkIndex: work.workIndex
+        }
+      } : void 0;
+      const baseInspection = {
         workIndex: work.workIndex,
         eventIndex: work.eventIndex,
         passIndex: work.passIndex,
-        attachment: attachment === void 0 ? void 0 : attachment.value
+        attachment: selectedAttachment
+      };
+      return ok({
+        ...baseInspection,
+        ...fields?.includes("pipeline") ? { pipeline: modelWork.pipeline } : {},
+        ...fields?.includes("bindings") ? {
+          bindings: modelWork.bindings,
+          vertexBuffers: modelWork.vertexBuffers,
+          indexBuffer: modelWork.indexBuffer,
+          shaders: modelWork.pipeline.shaders,
+          resourceIds: modelWork.bindings.map((binding) => binding.resourceId).filter((resourceId) => resourceId !== null)
+        } : {}
       });
     },
     async readResource(resourceId, subresource, signal) {
@@ -10000,7 +10332,10 @@ function readTexel(view, off, info, channelBytes) {
   }
   return out;
 }
-function decodeToRgba8(bytes, format, width, height) {
+function decodeToRgba8(bytes, format, width, height, aspect = "all") {
+  if (format.startsWith("depth")) {
+    return decodeDepthToRgba8(bytes, format, width, height, aspect);
+  }
   const info = formatInfo(format);
   const texBytes = bytesPerTexel(format);
   if (!info || texBytes === void 0) return null;
@@ -10032,6 +10367,26 @@ function decodeToRgba8(bytes, format, width, height) {
   }
   return out;
 }
+function decodeDepthToRgba8(bytes, format, width, height, aspect) {
+  const combined = format.endsWith("-stencil8");
+  if (combined && aspect === "all") return null;
+  if (!combined && aspect === "stencil-only") return null;
+  const stencil = aspect === "stencil-only";
+  const bytesPerValue = stencil ? 1 : 4;
+  const texelCount = width * height;
+  if (bytes.byteLength < texelCount * bytesPerValue) return null;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const out = new Uint8ClampedArray(new ArrayBuffer(texelCount * 4));
+  for (let index = 0; index < texelCount; index++) {
+    const value = stencil ? view.getUint8(index) : Math.round(clamp01(view.getFloat32(index * 4, true)) * 255);
+    const target = index * 4;
+    out[target] = value;
+    out[target + 1] = value;
+    out[target + 2] = value;
+    out[target + 3] = 255;
+  }
+  return out;
+}
 function decodeTexelRaw(bytes, format, width, height, texelX, texelY) {
   if (texelX < 0 || texelX >= width || texelY < 0 || texelY >= height) return null;
   const info = formatInfo(format);
@@ -10055,6 +10410,6 @@ function decodeTexelRaw(bytes, format, width, height, texelX, texelY) {
   return [r, channels[1], b, a];
 }
 
-export { EVENT_SEMANTICS, TAPE_MAGIC, TAPE_FORMAT_VERSION as V7_TAPE_FORMAT_VERSION, attachRecorder, buildFrameModel, buildTapeIndex, bytesPerTexel, createRhiDebugError, decodeTape, decodeTexelRaw, decodeToRgba8, encodeTape, eventKinds, formatInfo, halfToFloat, isWorkEvent, openReplay, readbackTexturePixels, resourceKindForEvent, workEventKinds };
+export { EVENT_SEMANTICS, TAPE_MAGIC, TAPE_FORMAT_VERSION as V7_TAPE_FORMAT_VERSION, attachRecorder, buildFrameModel, buildResourceLifecycle, buildTapeIndex, bytesPerTexel, createRhiDebugError, decodeTape, decodeTexelRaw, decodeToRgba8, encodeTape, eventKinds, formatInfo, halfToFloat, isWorkEvent, openReplay, readbackTexturePixels, replayDeviceRequest, resourceKindForEvent, workEventKinds };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map