@plasius/gpu-renderer 0.2.56 → 0.2.57

package/dist/index.js

@@ -3966,948 +3966,1289 @@ function boundsCentroid(bounds) {
   ];
 }
 
-// src/wavefront-sampling.js
-function buildOrthonormalBasis(normal) {
-  const tangentFallback = Math.abs(normal[1]) < 0.999 ? [0, 1, 0] : [1, 0, 0];
-  const tangent = normalize(cross2(tangentFallback, normal), [1, 0, 0]);
-  const bitangent = normalize(cross2(normal, tangent), [0, 0, 1]);
-  return { tangent, bitangent };
-}
-function localToWorld(local, normal) {
-  const basis = buildOrthonormalBasis(normal);
-  return normalize(
-    add(
-      add(scale(basis.tangent, local[0]), scale(basis.bitangent, local[1])),
-      scale(normal, local[2])
-    ),
-    normal
-  );
-}
-function radicalInverseVdc(bits) {
-  let value = bits >>> 0;
-  value = (value << 16 | value >>> 16) >>> 0;
-  value = ((value & 1431655765) << 1 | (value & 2863311530) >>> 1) >>> 0;
-  value = ((value & 858993459) << 2 | (value & 3435973836) >>> 2) >>> 0;
-  value = ((value & 252645135) << 4 | (value & 4042322160) >>> 4) >>> 0;
-  value = ((value & 16711935) << 8 | (value & 4278255360) >>> 8) >>> 0;
-  return value * 23283064365386963e-26;
-}
-function hammersley(index, count) {
-  return [index / Math.max(count, 1), radicalInverseVdc(index)];
-}
-function importanceSampleGgx(sample, roughness, normal) {
-  const alpha = Math.max(roughness * roughness, 1e-4);
-  const phi = 2 * Math.PI * sample[0];
-  const cosTheta = Math.sqrt((1 - sample[1]) / (1 + (alpha * alpha - 1) * sample[1]));
-  const sinTheta = Math.sqrt(Math.max(0, 1 - cosTheta * cosTheta));
-  const halfVector = localToWorld(
-    [Math.cos(phi) * sinTheta, Math.sin(phi) * sinTheta, cosTheta],
-    normal
-  );
-  return normalize(halfVector, normal);
-}
-function geometrySchlickGgx(nDotV, roughness) {
-  const k = (roughness + 1) * (roughness + 1) / 8;
-  return nDotV / Math.max(nDotV * (1 - k) + k, 1e-6);
-}
-function geometrySmith(nDotV, nDotL, roughness) {
-  return geometrySchlickGgx(nDotV, roughness) * geometrySchlickGgx(nDotL, roughness);
+// src/wavefront-runtime-support.js
+var WEBGPU_DEFAULT_MAX_STORAGE_BUFFER_BINDING_SIZE = 128 * 1024 * 1024;
+var WEBGPU_DEFAULT_MAX_BUFFER_SIZE = 256 * 1024 * 1024;
+function readRequestedDeviceLimit(source, name) {
+  const rawValue = source?.[name];
+  if (rawValue === void 0 || rawValue === null) {
+    return 0;
+  }
+  const value = Number(rawValue);
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative safe integer.`);
+  }
+  return value;
 }
-function integrateBrdfSample(nDotV, roughness, sampleCount) {
-  const viewDirection = [Math.sqrt(Math.max(0, 1 - nDotV * nDotV)), 0, nDotV];
-  const normal = [0, 0, 1];
-  let scaleTerm = 0;
-  let biasTerm = 0;
-  for (let index = 0; index < sampleCount; index += 1) {
-    const xi = hammersley(index, sampleCount);
-    const halfVector = importanceSampleGgx(xi, roughness, normal);
-    const vDotH = Math.max(dot(viewDirection, halfVector), 0);
-    const lightDirection = normalize(
-      subtract(scale(halfVector, 2 * vDotH), viewDirection),
-      normal
+function assertAdapterSupportsRequiredLimit(adapter, name, requiredValue) {
+  const availableValue = Number(adapter?.limits?.[name]);
+  if (!Number.isFinite(availableValue)) {
+    throw new Error(
+      `Wavefront scene buffers require ${name}>=${requiredValue} bytes, but this adapter does not expose that limit.`
+    );
+  }
+  if (availableValue < requiredValue) {
+    throw new Error(
+      `Wavefront scene buffers require ${name}>=${requiredValue} bytes, but this adapter exposes ${availableValue} bytes.`
     );
-    const nDotL = Math.max(lightDirection[2], 0);
-    const nDotH = Math.max(halfVector[2], 0);
-    if (nDotL <= 0 || nDotH <= 0 || vDotH <= 0) {
-      continue;
-    }
-    const geometry = geometrySmith(nDotV, nDotL, roughness);
-    const visibility = geometry * vDotH / Math.max(nDotH * nDotV, 1e-6);
-    const fresnel2 = (1 - vDotH) ** 5;
-    scaleTerm += (1 - fresnel2) * visibility;
-    biasTerm += fresnel2 * visibility;
   }
-  return [scaleTerm / sampleCount, biasTerm / sampleCount];
 }
-
-// src/wavefront-gpu-resources.js
-function clampTileSizeForDevice(config, device) {
-  const limit = Number(device?.limits?.maxStorageBufferBindingSize);
-  if (!Number.isFinite(limit) || limit <= 0) {
-    return config.tileSize;
+function getGpuUsageConstants() {
+  if (typeof GPUBufferUsage === "undefined" || typeof GPUTextureUsage === "undefined" || typeof GPUShaderStage === "undefined") {
+    throw new Error("WebGPU runtime unavailable. Required GPU constants are missing.");
   }
-  const maxPixelsByRay = Math.floor(limit / RAY_RECORD_BYTES);
-  const maxPixelsByHit = Math.floor(limit / HIT_RECORD_BYTES);
-  const maxPixelsByPathVertex = Math.floor(
-    limit / ((config.maxDepth + 1) * PATH_VERTEX_RECORD_BYTES)
-  );
-  const maxPixels = Math.max(
-    256,
-    Math.min(maxPixelsByRay, maxPixelsByHit, maxPixelsByPathVertex)
-  );
-  if (config.tilePixelCapacity <= maxPixels) {
-    return config.tileSize;
+  if (typeof GPUBufferUsage.INDIRECT !== "number") {
+    throw new Error("WebGPU runtime unavailable. GPUBufferUsage.INDIRECT is missing.");
   }
-  return Math.max(16, Math.floor(Math.sqrt(maxPixels)));
-}
-function createBuffer(device, usage, size, label) {
-  return device.createBuffer({
-    label,
-    size: Math.max(4, size),
-    usage
-  });
-}
-function alignTo(value, alignment) {
-  const resolvedAlignment = Math.max(1, alignment);
-  return Math.ceil(value / resolvedAlignment) * resolvedAlignment;
+  return {
+    buffer: GPUBufferUsage,
+    texture: GPUTextureUsage,
+    shader: GPUShaderStage,
+    map: typeof GPUMapMode === "undefined" ? null : GPUMapMode
+  };
 }
-function float32ToFloat16Bits(value) {
-  const floatView = new Float32Array(1);
-  const intView = new Uint32Array(floatView.buffer);
-  floatView[0] = Number.isFinite(value) ? value : 0;
-  const x = intView[0];
-  const sign = x >> 16 & 32768;
-  let mantissa = x & 8388607;
-  let exponent = x >> 23 & 255;
-  if (exponent === 255) {
-    return sign | (mantissa ? 32256 : 31744);
+function resolveCanvas3(canvasOrSelector, documentRef = globalThis.document) {
+  if (typeof canvasOrSelector === "string") {
+    const resolved = documentRef?.querySelector?.(canvasOrSelector);
+    if (!resolved) {
+      throw new Error(`Unable to find canvas for selector: ${canvasOrSelector}`);
+    }
+    return resolved;
   }
-  exponent = exponent - 127 + 15;
-  if (exponent >= 31) {
-    return sign | 31744;
+  if (canvasOrSelector?.getContext) {
+    return canvasOrSelector;
   }
-  if (exponent <= 0) {
-    if (exponent < -10) {
-      return sign;
-    }
-    mantissa = (mantissa | 8388608) >> 1 - exponent;
-    return sign | mantissa + 4096 >> 13;
+  const fallback = documentRef?.querySelector?.("canvas[data-plasius-wavefront-path-tracing]");
+  if (!fallback) {
+    throw new Error("A canvas is required for WebGPU wavefront path tracing.");
   }
-  return sign | exponent << 10 | mantissa + 4096 >> 13;
+  return fallback;
 }
-function environmentMapIntegerScale(data) {
-  if (data instanceof Uint8Array) {
-    return 1 / 255;
+async function getPipelineDiagnostics(shaderModule) {
+  if (typeof shaderModule?.getCompilationInfo !== "function") {
+    return "";
   }
-  if (data instanceof Uint16Array) {
-    return 1 / 65535;
+  try {
+    const info = await shaderModule.getCompilationInfo();
+    const messages = info.messages ?? [];
+    if (messages.length === 0) {
+      return "";
+    }
+    return messages.map((message) => {
+      const line = message.lineNum ?? "?";
+      const column = message.linePos ?? "?";
+      return `line ${line}:${column} ${message.message}`;
+    }).join("\n");
+  } catch {
+    return "";
   }
-  return 1;
 }
-function environmentMapHasSamplingData(environmentMap) {
-  if (!environmentMap || !environmentMap.data) {
-    return false;
+async function createComputePipeline(device, shaderModule, layout, entryPoint, label) {
+  const descriptor = {
+    label,
+    layout,
+    compute: {
+      module: shaderModule,
+      entryPoint
+    }
+  };
+  try {
+    if (typeof device.createComputePipelineAsync === "function") {
+      return await device.createComputePipelineAsync(descriptor);
+    }
+    return device.createComputePipeline(descriptor);
+  } catch (error) {
+    const diagnostics = await getPipelineDiagnostics(shaderModule);
+    const suffix = diagnostics ? `
+${diagnostics}` : "";
+    throw new Error(`WGSL compilation failed for ${label}: ${error.message}${suffix}`, {
+      cause: error
+    });
   }
-  const width = Math.max(1, environmentMap.width ?? 1);
-  const height = Math.max(1, environmentMap.height ?? 1);
-  return environmentMap.data.length >= width * height * 4;
 }
-function createRgba8TextureUpload(source) {
-  const width = Math.max(1, Math.trunc(source.width));
-  const height = Math.max(1, Math.trunc(source.height));
-  const bytesPerRow = alignTo(width * 4, 256);
-  const bytes = new Uint8Array(bytesPerRow * height);
-  const data = source.data instanceof Uint8Array ? source.data : new Uint8Array(source.data);
-  for (let y = 0; y < height; y += 1) {
-    const sourceOffset = y * width * 4;
-    const targetOffset = y * bytesPerRow;
-    bytes.set(data.subarray(sourceOffset, sourceOffset + width * 4), targetOffset);
+async function assertShaderModuleCompiles(shaderModule, label) {
+  if (typeof shaderModule?.getCompilationInfo !== "function") {
+    return;
   }
-  return Object.freeze({
-    bytes,
-    bytesPerRow,
-    width,
-    height
-  });
+  const info = await shaderModule.getCompilationInfo();
+  const messages = Array.isArray(info?.messages) ? info.messages : [];
+  const errors = messages.filter((message) => message?.type === "error");
+  if (errors.length <= 0) {
+    return;
+  }
+  const diagnostics = errors.map((message) => {
+    const line = Number.isFinite(message.lineNum) ? message.lineNum : "?";
+    const column = Number.isFinite(message.linePos) ? message.linePos : "?";
+    return `line ${line}:${column} ${message.message}`;
+  }).join("\n");
+  throw new Error(`WGSL compilation preflight failed for ${label}:
+${diagnostics}`);
 }
-function readEnvironmentMapComponent(data, index, fallback, integerScale = 1) {
-  if (!data || index >= data.length) {
-    return fallback;
+async function createRenderPipeline(device, descriptor) {
+  if (typeof device.createRenderPipelineAsync === "function") {
+    return device.createRenderPipelineAsync(descriptor);
   }
-  const value = Number(data[index]);
-  return Number.isFinite(value) ? Math.max(0, value) * integerScale : fallback;
+  return device.createRenderPipeline(descriptor);
 }
-function createBrdfLutUploadBytes(size = DEFAULT_BRDF_LUT_SIZE, sampleCount = DEFAULT_BRDF_LUT_SAMPLE_COUNT) {
-  const cacheKey = `${Math.max(1, Math.trunc(size))}:${Math.max(1, Math.trunc(sampleCount))}`;
-  const cached = BRDF_LUT_UPLOAD_CACHE.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const width = Math.max(1, Math.trunc(size));
-  const height = Math.max(1, Math.trunc(size));
-  const rowBytes = width * 8;
-  const bytesPerRow = alignTo(rowBytes, 256);
-  const bytes = new Uint8Array(bytesPerRow * height);
-  const view = new DataView(bytes.buffer);
-  for (let y = 0; y < height; y += 1) {
-    const roughness = (y + 0.5) / height;
-    for (let x = 0; x < width; x += 1) {
-      const nDotV = Math.max((x + 0.5) / width, 1e-4);
-      const [scaleTerm, biasTerm] = integrateBrdfSample(nDotV, roughness, sampleCount);
-      const offset = y * bytesPerRow + x * 8;
-      view.setUint16(offset, float32ToFloat16Bits(scaleTerm), true);
-      view.setUint16(offset + 2, float32ToFloat16Bits(biasTerm), true);
-      view.setUint16(offset + 4, float32ToFloat16Bits(0), true);
-      view.setUint16(offset + 6, float32ToFloat16Bits(1), true);
-    }
-  }
-  const upload = Object.freeze({ bytes, bytesPerRow, width, height });
-  BRDF_LUT_UPLOAD_CACHE.set(cacheKey, upload);
-  return upload;
-}
-function createLinearEnvironmentPixels(environmentMap, fallbackColor) {
-  const width = Math.max(1, environmentMap.width);
-  const height = Math.max(1, environmentMap.height);
-  const pixels = new Float32Array(width * height * 4);
-  const data = environmentMap.data;
-  const integerScale = environmentMapIntegerScale(data);
-  for (let index = 0; index < width * height; index += 1) {
-    const sourceOffset = index * 4;
-    const targetOffset = index * 4;
-    pixels[targetOffset] = readEnvironmentMapComponent(data, sourceOffset, fallbackColor[0], integerScale);
-    pixels[targetOffset + 1] = readEnvironmentMapComponent(data, sourceOffset + 1, fallbackColor[1], integerScale);
-    pixels[targetOffset + 2] = readEnvironmentMapComponent(data, sourceOffset + 2, fallbackColor[2], integerScale);
-    pixels[targetOffset + 3] = readEnvironmentMapComponent(data, sourceOffset + 3, fallbackColor[3] ?? 1, integerScale);
-  }
-  return pixels;
-}
-function environmentUvToDirection(u, v, rotationRadians = 0) {
-  const angle = (u - rotationRadians / (2 * Math.PI) - 0.5) * 2 * Math.PI;
-  const theta = v * Math.PI;
-  const sinTheta = Math.sin(theta);
-  return [
-    Math.cos(angle) * sinTheta,
-    Math.cos(theta),
-    Math.sin(angle) * sinTheta
-  ];
-}
-function sampleEnvironmentPixelsBilinear(pixels, width, height, u, v) {
-  const wrappedU = (u % 1 + 1) % 1;
-  const clampedV = clamp2(v, 0, 1);
-  const x = wrappedU * width - 0.5;
-  const y = clampedV * height - 0.5;
-  const x0 = (Math.floor(x) % width + width) % width;
-  const y0 = clamp2(Math.floor(y), 0, height - 1);
-  const x1 = (x0 + 1) % width;
-  const y1 = clamp2(y0 + 1, 0, height - 1);
-  const tx = x - Math.floor(x);
-  const ty = y - Math.floor(y);
-  const read = (px, py) => {
-    const offset = (py * width + px) * 4;
-    return [pixels[offset], pixels[offset + 1], pixels[offset + 2], pixels[offset + 3]];
+function createWavefrontDeviceDescriptor(adapter, options = {}, memory = null) {
+  const descriptor = { ...options.deviceDescriptor ?? {} };
+  const descriptorRequiredLimits = { ...descriptor.requiredLimits ?? {} };
+  const requiredLimits = {
+    ...descriptorRequiredLimits,
+    ...options.requiredLimits ?? {}
   };
-  const a = read(x0, y0);
-  const b = read(x1, y0);
-  const c = read(x0, y1);
-  const d = read(x1, y1);
-  const mixPair = (first, second, factor) => first * (1 - factor) + second * factor;
-  return [
-    mixPair(mixPair(a[0], b[0], tx), mixPair(c[0], d[0], tx), ty),
-    mixPair(mixPair(a[1], b[1], tx), mixPair(c[1], d[1], tx), ty),
-    mixPair(mixPair(a[2], b[2], tx), mixPair(c[2], d[2], tx), ty),
-    mixPair(mixPair(a[3], b[3], tx), mixPair(c[3], d[3], tx), ty)
-  ];
-}
-function directionToEnvironmentUv(direction, rotationRadians = 0) {
-  const unitDirection = normalize(direction, [0, 1, 0]);
-  const rotationTurns = rotationRadians / (2 * Math.PI);
-  const u = ((Math.atan2(unitDirection[2], unitDirection[0]) / (2 * Math.PI) + 0.5 + rotationTurns) % 1 + 1) % 1;
-  const v = Math.acos(clamp2(unitDirection[1], -1, 1)) / Math.PI;
-  return [u, clamp2(v, 0, 1)];
-}
-function sampleEnvironmentRadiance(pixels, width, height, direction, rotationRadians = 0) {
-  const [u, v] = directionToEnvironmentUv(direction, rotationRadians);
-  return sampleEnvironmentPixelsBilinear(pixels, width, height, u, v);
-}
-function createFloat16RgbaUploadFromLevels(levels) {
-  return levels.map((level) => {
-    const rowBytes = level.width * 8;
-    const bytesPerRow = alignTo(rowBytes, 256);
-    const bytes = new Uint8Array(bytesPerRow * level.height);
-    const view = new DataView(bytes.buffer);
-    for (let y = 0; y < level.height; y += 1) {
-      for (let x = 0; x < level.width; x += 1) {
-        const sourceOffset = (y * level.width + x) * 4;
-        const targetOffset = y * bytesPerRow + x * 8;
-        view.setUint16(targetOffset, float32ToFloat16Bits(level.data[sourceOffset]), true);
-        view.setUint16(targetOffset + 2, float32ToFloat16Bits(level.data[sourceOffset + 1]), true);
-        view.setUint16(targetOffset + 4, float32ToFloat16Bits(level.data[sourceOffset + 2]), true);
-        view.setUint16(targetOffset + 6, float32ToFloat16Bits(level.data[sourceOffset + 3]), true);
-      }
+  const traceStorageBindings = TRACE_STORAGE_BUFFER_BINDINGS;
+  const traceTextureBindings = TRACE_SAMPLED_TEXTURE_BINDINGS + (options.instances !== void 0 ? 1 : 0);
+  const exposedStorageBufferLimit = Number(adapter?.limits?.maxStorageBuffersPerShaderStage);
+  if (Number.isFinite(exposedStorageBufferLimit)) {
+    if (exposedStorageBufferLimit < traceStorageBindings) {
+      throw new Error(
+        `Wavefront mesh tracing requires maxStorageBuffersPerShaderStage>=${traceStorageBindings}, but this adapter exposes ${exposedStorageBufferLimit}.`
+      );
     }
-    return Object.freeze({ bytes, bytesPerRow, width: level.width, height: level.height });
-  });
-}
-function createPrefilteredEnvironmentLevels(environmentMap, fallbackColor) {
-  const sourcePixels = createLinearEnvironmentPixels(environmentMap, fallbackColor);
-  const sourceWidth = Math.max(1, environmentMap.width);
-  const sourceHeight = Math.max(1, environmentMap.height);
-  const mipLevelCount = Math.max(1, Math.floor(Math.log2(Math.max(sourceWidth, sourceHeight))) + 1);
-  const levels = [
-    Object.freeze({
-      width: sourceWidth,
-      height: sourceHeight,
-      data: sourcePixels
-    })
-  ];
-  for (let mipLevel = 1; mipLevel < mipLevelCount; mipLevel += 1) {
-    const width = Math.max(1, sourceWidth >> mipLevel);
-    const height = Math.max(1, sourceHeight >> mipLevel);
-    const roughness = mipLevelCount <= 1 ? 0 : mipLevel / (mipLevelCount - 1);
-    const data = new Float32Array(width * height * 4);
-    const sampleCount = roughness < 0.25 ? 64 : roughness < 0.6 ? 96 : 128;
-    for (let y = 0; y < height; y += 1) {
-      for (let x = 0; x < width; x += 1) {
-        const direction = environmentUvToDirection((x + 0.5) / width, (y + 0.5) / height, environmentMap.rotationRadians);
-        const normal = normalize(direction, [0, 1, 0]);
-        const viewDirection = normal;
-        let totalWeight = 0;
-        const accum = [0, 0, 0];
-        for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex += 1) {
-          const xi = hammersley(sampleIndex, sampleCount);
-          const halfVector = importanceSampleGgx(xi, roughness, normal);
-          const viewDotHalf = Math.max(dot(viewDirection, halfVector), 0);
-          const lightDirection = normalize(
-            subtract(scale(halfVector, 2 * viewDotHalf), viewDirection),
-            normal
-          );
-          const nDotL = Math.max(dot(normal, lightDirection), 0);
-          if (nDotL <= 1e-6) {
-            continue;
-          }
-          const radiance = sampleEnvironmentRadiance(
-            sourcePixels,
-            sourceWidth,
-            sourceHeight,
-            lightDirection,
-            environmentMap.rotationRadians
-          );
-          accum[0] += radiance[0] * nDotL;
-          accum[1] += radiance[1] * nDotL;
-          accum[2] += radiance[2] * nDotL;
-          totalWeight += nDotL;
-        }
-        const offset = (y * width + x) * 4;
-        data[offset] = accum[0] / Math.max(totalWeight, 1e-6);
-        data[offset + 1] = accum[1] / Math.max(totalWeight, 1e-6);
-        data[offset + 2] = accum[2] / Math.max(totalWeight, 1e-6);
-        data[offset + 3] = 1;
-      }
+    requiredLimits.maxStorageBuffersPerShaderStage = Math.max(
+      Number(requiredLimits.maxStorageBuffersPerShaderStage ?? 0),
+      traceStorageBindings
+    );
+  }
+  const exposedSampledTextureLimit = Number(adapter?.limits?.maxSampledTexturesPerShaderStage);
+  if (Number.isFinite(exposedSampledTextureLimit)) {
+    if (exposedSampledTextureLimit < traceTextureBindings) {
+      throw new Error(
+        `Wavefront material tracing requires maxSampledTexturesPerShaderStage>=${traceTextureBindings}, but this adapter exposes ${exposedSampledTextureLimit}.`
+      );
     }
-    levels.push(Object.freeze({ width, height, data }));
+    requiredLimits.maxSampledTexturesPerShaderStage = Math.max(
+      Number(requiredLimits.maxSampledTexturesPerShaderStage ?? 0),
+      traceTextureBindings
+    );
   }
-  return Object.freeze({
-    levels,
-    mipLevelCount,
-    width: sourceWidth,
-    height: sourceHeight
-  });
-}
-function createEnvironmentSamplingTables(environmentMap, fallbackColor) {
-  if (!environmentMapHasSamplingData(environmentMap)) {
-    return Object.freeze({
-      width: 1,
-      height: 1,
-      pdf: new Float32Array([1]),
-      marginalCdf: new Float32Array([1]),
-      conditionalCdf: new Float32Array([1]),
-      hasImportanceData: false
-    });
+  const sceneStorageBufferBindingBytes = Number(
+    memory?.sceneStorageBufferBindingBytes ?? 0
+  );
+  const requestedStorageBufferBindingSize = Math.max(
+    readRequestedDeviceLimit(descriptorRequiredLimits, "maxStorageBufferBindingSize"),
+    readRequestedDeviceLimit(options.requiredLimits, "maxStorageBufferBindingSize"),
+    sceneStorageBufferBindingBytes > WEBGPU_DEFAULT_MAX_STORAGE_BUFFER_BINDING_SIZE ? sceneStorageBufferBindingBytes : 0
+  );
+  if (requestedStorageBufferBindingSize > 0) {
+    assertAdapterSupportsRequiredLimit(
+      adapter,
+      "maxStorageBufferBindingSize",
+      requestedStorageBufferBindingSize
+    );
+    requiredLimits.maxStorageBufferBindingSize = requestedStorageBufferBindingSize;
   }
-  const pixels = createLinearEnvironmentPixels(environmentMap, fallbackColor);
-  const width = Math.max(1, environmentMap.width);
-  const height = Math.max(1, environmentMap.height);
-  const pdf = new Float32Array(width * height);
-  const marginalCdf = new Float32Array(height);
-  const conditionalCdf = new Float32Array(width * height);
-  const rowSums = new Float32Array(height);
-  let totalWeight = 0;
-  for (let y = 0; y < height; y += 1) {
-    const theta = (y + 0.5) / height * Math.PI;
-    const sinTheta = Math.max(Math.sin(theta), 1e-4);
-    let rowWeight = 0;
-    for (let x = 0; x < width; x += 1) {
-      const offset = (y * width + x) * 4;
-      const luminance = pixels[offset] * 0.2126 + pixels[offset + 1] * 0.7152 + pixels[offset + 2] * 0.0722;
-      const weight = Math.max(luminance * sinTheta, 1e-6);
-      pdf[y * width + x] = weight;
-      rowWeight += weight;
-      conditionalCdf[y * width + x] = rowWeight;
-    }
-    rowSums[y] = rowWeight;
-    totalWeight += rowWeight;
-    if (rowWeight > 0) {
-      for (let x = 0; x < width; x += 1) {
-        conditionalCdf[y * width + x] /= rowWeight;
-      }
-    } else {
-      for (let x = 0; x < width; x += 1) {
-        conditionalCdf[y * width + x] = (x + 1) / width;
-      }
-    }
-    marginalCdf[y] = totalWeight;
+  const requestedMaxBufferSize = Math.max(
+    readRequestedDeviceLimit(descriptorRequiredLimits, "maxBufferSize"),
+    readRequestedDeviceLimit(options.requiredLimits, "maxBufferSize"),
+    sceneStorageBufferBindingBytes > WEBGPU_DEFAULT_MAX_BUFFER_SIZE ? sceneStorageBufferBindingBytes : 0,
+    requestedStorageBufferBindingSize > WEBGPU_DEFAULT_MAX_BUFFER_SIZE ? requestedStorageBufferBindingSize : 0
+  );
+  if (requestedMaxBufferSize > 0) {
+    assertAdapterSupportsRequiredLimit(adapter, "maxBufferSize", requestedMaxBufferSize);
+    requiredLimits.maxBufferSize = requestedMaxBufferSize;
   }
-  for (let y = 0; y < height; y += 1) {
-    marginalCdf[y] /= Math.max(totalWeight, 1e-6);
+  const requiredFeatures = Array.from(descriptor.requiredFeatures ?? []);
+  const adapterFeatures = adapter?.features;
+  const timestampQuerySupported = typeof adapterFeatures?.has === "function" ? adapterFeatures.has("timestamp-query") : adapterFeatures && typeof adapterFeatures[Symbol.iterator] === "function" ? Array.from(adapterFeatures).includes("timestamp-query") : false;
+  if (options.gpuTimestamps !== false && timestampQuerySupported && !requiredFeatures.includes("timestamp-query")) {
+    requiredFeatures.push("timestamp-query");
   }
-  for (let index = 0; index < pdf.length; index += 1) {
-    pdf[index] /= Math.max(totalWeight, 1e-6);
+  if (requiredFeatures.length > 0) {
+    descriptor.requiredFeatures = requiredFeatures;
   }
-  return Object.freeze({
-    width,
-    height,
-    pdf,
-    marginalCdf,
-    conditionalCdf,
-    hasImportanceData: true
-  });
-}
-function createEnvironmentMapResource(device, constants, environmentMap, fallbackColor) {
-  if (environmentMap.view) {
-    return Object.freeze({
-      view: environmentMap.view,
-      sampler: environmentMap.sampler ?? device.createSampler({
-        label: "plasius.wavefront.environmentMapSampler",
-        addressModeU: "repeat",
-        addressModeV: "clamp-to-edge",
-        magFilter: "linear",
-        minFilter: "linear",
-        mipmapFilter: "linear"
-      }),
-      texture: null,
-      ownsTexture: false,
-      width: Math.max(1, environmentMap.width),
-      height: Math.max(1, environmentMap.height),
-      mipLevelCount: Math.max(1, environmentMap.mipLevelCount ?? 1)
-    });
+  if (Object.keys(requiredLimits).length > 0) {
+    descriptor.requiredLimits = {
+      ...descriptor.requiredLimits ?? {},
+      ...requiredLimits
+    };
   }
-  if (environmentMap.texture && typeof environmentMap.texture.createView === "function") {
-    return Object.freeze({
-      view: environmentMap.texture.createView(),
-      sampler: environmentMap.sampler ?? device.createSampler({
-        label: "plasius.wavefront.environmentMapSampler",
-        addressModeU: "repeat",
-        addressModeV: "clamp-to-edge",
-        magFilter: "linear",
-        minFilter: "linear",
-        mipmapFilter: "linear"
-      }),
-      texture: environmentMap.texture,
-      ownsTexture: false,
-      width: Math.max(1, environmentMap.width),
-      height: Math.max(1, environmentMap.height),
-      mipLevelCount: Math.max(1, environmentMap.mipLevelCount ?? 1)
-    });
+  return Object.keys(descriptor).length > 0 ? descriptor : void 0;
+}
+function readGpuLimit(adapter, device, name) {
+  const adapterValue = Number(adapter?.limits?.[name]);
+  if (Number.isFinite(adapterValue)) {
+    return adapterValue;
   }
-  const prefiltered = createPrefilteredEnvironmentLevels(environmentMap, fallbackColor);
-  const uploads = createFloat16RgbaUploadFromLevels(prefiltered.levels);
-  const texture = device.createTexture({
-    label: environmentMap.enabled ? "plasius.wavefront.environmentMap" : "plasius.wavefront.environmentMapFallback",
-    size: { width: prefiltered.width, height: prefiltered.height },
-    format: "rgba16float",
-    mipLevelCount: prefiltered.mipLevelCount,
-    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
-  });
-  uploads.forEach((upload, mipLevel) => {
-    device.queue.writeTexture(
-      { texture, mipLevel },
-      upload.bytes,
-      { bytesPerRow: upload.bytesPerRow, rowsPerImage: upload.height },
-      { width: upload.width, height: upload.height, depthOrArrayLayers: 1 }
-    );
-  });
-  return Object.freeze({
-    view: texture.createView(),
-    sampler: environmentMap.sampler ?? device.createSampler({
-      label: "plasius.wavefront.environmentMapSampler",
-      addressModeU: "repeat",
-      addressModeV: "clamp-to-edge",
-      magFilter: "linear",
-      minFilter: "linear",
-      mipmapFilter: "linear"
-    }),
-    texture,
-    ownsTexture: true,
-    width: prefiltered.width,
-    height: prefiltered.height,
-    mipLevelCount: prefiltered.mipLevelCount
-  });
+  const deviceValue = Number(device?.limits?.[name]);
+  return Number.isFinite(deviceValue) ? deviceValue : null;
 }
-function createEnvironmentSamplingTextureResource(device, constants, environmentMap, fallbackColor) {
-  const tables = createEnvironmentSamplingTables(environmentMap, fallbackColor);
-  const rowBytes = tables.width * 8;
-  const bytesPerRow = alignTo(rowBytes, 256);
-  const bytes = new Uint8Array(bytesPerRow * tables.height);
-  const view = new DataView(bytes.buffer);
-  for (let y = 0; y < tables.height; y += 1) {
-    for (let x = 0; x < tables.width; x += 1) {
-      const probability = tables.pdf[y * tables.width + x];
-      const conditional = tables.conditionalCdf[y * tables.width + x];
-      const marginal = tables.marginalCdf[y];
-      const offset = y * bytesPerRow + x * 8;
-      view.setUint16(offset, float32ToFloat16Bits(probability), true);
-      view.setUint16(offset + 2, float32ToFloat16Bits(conditional), true);
-      view.setUint16(offset + 4, float32ToFloat16Bits(marginal), true);
-      view.setUint16(offset + 6, float32ToFloat16Bits(1), true);
-    }
+function createAdapterInfoSnapshot(adapter) {
+  const info = adapter?.info;
+  if (!info || typeof info !== "object") {
+    return null;
   }
-  const texture = device.createTexture({
-    label: "plasius.wavefront.environmentSampling",
-    size: { width: tables.width, height: tables.height },
-    format: "rgba16float",
-    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
-  });
-  device.queue.writeTexture(
-    { texture },
-    bytes,
-    { bytesPerRow, rowsPerImage: tables.height },
-    { width: tables.width, height: tables.height, depthOrArrayLayers: 1 }
-  );
   return Object.freeze({
-    view: texture.createView(),
-    texture,
-    ownsTexture: true,
-    hasImportanceData: tables.hasImportanceData
+    vendor: typeof info.vendor === "string" ? info.vendor : "",
+    architecture: typeof info.architecture === "string" ? info.architecture : "",
+    device: typeof info.device === "string" ? info.device : "",
+    description: typeof info.description === "string" ? info.description : ""
   });
 }
-function createBrdfLutResource(device, constants, size = DEFAULT_BRDF_LUT_SIZE) {
-  const upload = createBrdfLutUploadBytes(size);
-  const texture = device.createTexture({
-    label: "plasius.wavefront.brdfLut",
-    size: { width: upload.width, height: upload.height },
-    format: "rgba16float",
-    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
-  });
-  device.queue.writeTexture(
-    { texture },
-    upload.bytes,
-    { bytesPerRow: upload.bytesPerRow, rowsPerImage: upload.height },
-    { width: upload.width, height: upload.height, depthOrArrayLayers: 1 }
-  );
+function createGpuAdapterParallelismDiagnostics(adapter, device) {
   return Object.freeze({
-    view: texture.createView(),
-    sampler: device.createSampler({
-      label: "plasius.wavefront.brdfLutSampler",
-      addressModeU: "clamp-to-edge",
-      addressModeV: "clamp-to-edge",
-      magFilter: "linear",
-      minFilter: "linear"
+    physicalCoreCount: null,
+    physicalCoreCountAvailable: false,
+    physicalCoreCountUnavailableReason: "WebGPU does not expose physical GPU core counts.",
+    adapterInfo: createAdapterInfoSnapshot(adapter),
+    adapterLimits: Object.freeze({
+      maxComputeInvocationsPerWorkgroup: readGpuLimit(adapter, device, "maxComputeInvocationsPerWorkgroup"),
+      maxComputeWorkgroupSizeX: readGpuLimit(adapter, device, "maxComputeWorkgroupSizeX"),
+      maxComputeWorkgroupSizeY: readGpuLimit(adapter, device, "maxComputeWorkgroupSizeY"),
+      maxComputeWorkgroupSizeZ: readGpuLimit(adapter, device, "maxComputeWorkgroupSizeZ"),
+      maxComputeWorkgroupsPerDimension: readGpuLimit(adapter, device, "maxComputeWorkgroupsPerDimension"),
+      maxStorageBuffersPerShaderStage: readGpuLimit(adapter, device, "maxStorageBuffersPerShaderStage"),
+      maxStorageBufferBindingSize: readGpuLimit(adapter, device, "maxStorageBufferBindingSize"),
+      maxBufferSize: readGpuLimit(adapter, device, "maxBufferSize")
     }),
-    texture,
-    ownsTexture: true,
-    width: upload.width,
-    height: upload.height
+    configuredWorkgroupSize: WORKGROUP_SIZE
   });
 }
-function createMediumTextureResource(device, constants, mediums) {
-  const normalized = Array.isArray(mediums) && mediums.length > 0 ? mediums : [{ id: 0 }];
-  const width = Math.max(
+function createEnvironmentMapSnapshot(environmentMap) {
+  return Object.freeze({
+    enabled: environmentMap.enabled,
+    width: environmentMap.width,
+    height: environmentMap.height,
+    mipLevelCount: environmentMap.mipLevelCount ?? 1,
+    projection: environmentMap.projection,
+    intensity: environmentMap.intensity,
+    rotationRadians: environmentMap.rotationRadians,
+    ambientStrength: environmentMap.ambientStrength,
+    hasImportanceData: environmentMap.hasImportanceData === true
+  });
+}
+function nowMs3() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function estimateAccelerationBuildWaitFactor(config) {
+  if (config?.gpuAccelerationBuildRequired !== true) {
+    return 1;
+  }
+  const bvhSortStageCount = Array.isArray(config?.bvhSortStages) ? config.bvhSortStages.length : 0;
+  const bvhBuildLevelCount = Array.isArray(config?.bvhBuildLevels) ? config.bvhBuildLevels.length : 0;
+  const accelerationStageCount = 2 + bvhSortStageCount + bvhBuildLevelCount;
+  return Math.max(1, 1 + accelerationStageCount / 96);
+}
+function estimateSubmittedGpuWorkTiming(config, tileCount, overrideTimeoutMs = null, options = {}) {
+  if (Number.isFinite(overrideTimeoutMs)) {
+    const overrideMs = Math.max(1, Math.trunc(Number(overrideTimeoutMs)));
+    return Object.freeze({
+      timeoutMs: overrideMs,
+      maxWaitMs: overrideMs
+    });
+  }
+  const samplesPerPixel = Math.max(
     1,
-    normalized.reduce((maximum, medium) => Math.max(maximum, medium.id ?? 0), 0) + 1
+    Number(config?.renderedSamplesPerPixel ?? config?.samplesPerPixel ?? 1)
   );
-  const level = {
-    width,
-    height: MEDIUM_TABLE_ROWS,
-    data: new Float32Array(width * MEDIUM_TABLE_ROWS * 4)
-  };
-  for (const medium of normalized) {
-    const mediumId = Math.max(0, Math.trunc(Number(medium.id) || 0));
-    const absorptionOffset = mediumId * 4;
-    level.data[absorptionOffset] = Math.max(0, medium.absorption?.[0] ?? 0);
-    level.data[absorptionOffset + 1] = Math.max(0, medium.absorption?.[1] ?? 0);
-    level.data[absorptionOffset + 2] = Math.max(0, medium.absorption?.[2] ?? 0);
-    level.data[absorptionOffset + 3] = Math.max(0, medium.phaseModel ?? 0);
-    const scatteringOffset = (width + mediumId) * 4;
-    level.data[scatteringOffset] = Math.max(0, medium.scattering?.[0] ?? 0);
-    level.data[scatteringOffset + 1] = Math.max(0, medium.scattering?.[1] ?? 0);
-    level.data[scatteringOffset + 2] = Math.max(0, medium.scattering?.[2] ?? 0);
-    level.data[scatteringOffset + 3] = Math.max(0, medium.density ?? 0);
-  }
-  const upload = createFloat16RgbaUploadFromLevels([level])[0];
-  const texture = device.createTexture({
-    label: "plasius.wavefront.mediumTable",
-    size: { width, height: MEDIUM_TABLE_ROWS },
-    format: "rgba16float",
-    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
-  });
-  device.queue.writeTexture(
-    { texture },
-    upload.bytes,
-    { bytesPerRow: upload.bytesPerRow, rowsPerImage: upload.height },
-    { width, height: MEDIUM_TABLE_ROWS, depthOrArrayLayers: 1 }
+  const maxDepth = Math.max(1, Number(config?.maxDepth ?? 1));
+  const deferredResolvePasses = config?.deferredPathResolve ? 1 : 0;
+  const denoisePasses = config?.denoise ? samplesPerPixel < 4 ? 2 : 1 : 0;
+  const tiles = Math.max(1, Number(tileCount ?? 1));
+  const estimatedPasses = tiles * (samplesPerPixel * (maxDepth + 1 + deferredResolvePasses) + denoisePasses + 1);
+  const triangleCount = Math.max(0, Number(config?.triangleCount ?? 0));
+  const geometryFactor = Math.max(1, triangleCount / 131072);
+  const includeAccelerationBuild = options.includeAccelerationBuild === true;
+  const accelerationFactor = includeAccelerationBuild ? estimateAccelerationBuildWaitFactor(config) : 1;
+  const estimatedWindowMs = Math.round(
+    (GPU_SUBMITTED_WORK_TIMEOUT_MS + estimatedPasses * 5) * geometryFactor * accelerationFactor
+  );
+  const timeoutMs = Math.min(
+    GPU_MAX_SUBMITTED_WORK_TIMEOUT_MS,
+    Math.max(GPU_SUBMITTED_WORK_TIMEOUT_MS, estimatedWindowMs)
+  );
+  const maxWaitMultiplier = includeAccelerationBuild ? 3 : 2;
+  const maxWaitMs = Math.min(
+    GPU_MAX_SUBMITTED_WORK_DEADLINE_MS,
+    Math.max(timeoutMs, estimatedWindowMs * maxWaitMultiplier)
   );
   return Object.freeze({
-    texture,
-    view: texture.createView(),
-    ownsTexture: true,
-    count: normalized.length,
-    width
+    timeoutMs,
+    maxWaitMs
   });
 }
-function mediumTablesEqual(left, right) {
-  const leftMediums = Array.isArray(left) ? left : [];
-  const rightMediums = Array.isArray(right) ? right : [];
-  if (leftMediums.length !== rightMediums.length) {
-    return false;
+
+// src/wavefront-gpu-synchronization.js
+async function waitForSubmittedGpuWork(device, options = {}) {
+  if (typeof device.queue.onSubmittedWorkDone !== "function") {
+    return true;
   }
-  for (let index = 0; index < leftMediums.length; index += 1) {
-    const leftMedium = leftMediums[index];
-    const rightMedium = rightMediums[index];
-    if ((leftMedium?.id ?? 0) !== (rightMedium?.id ?? 0)) {
-      return false;
-    }
-    if ((leftMedium?.phaseModel ?? 0) !== (rightMedium?.phaseModel ?? 0)) {
-      return false;
+  const timeoutMs = Math.max(
+    1,
+    Number.isFinite(options.timeoutMs) ? Number(options.timeoutMs) : GPU_SUBMITTED_WORK_TIMEOUT_MS
+  );
+  const maxWaitMs = Math.max(
+    timeoutMs,
+    Number.isFinite(options.maxWaitMs) ? Number(options.maxWaitMs) : timeoutMs
+  );
+  const allowTimeout = options.allowTimeout !== false;
+  const completionPromise = device.queue.onSubmittedWorkDone().then(
+    () => ({ status: "done" }),
+    (error) => {
+      throw error;
     }
-    if ((leftMedium?.density ?? 0) !== (rightMedium?.density ?? 0)) {
+  );
+  const lossPromise = typeof device.lost?.then === "function" ? device.lost.then((info) => {
+    throw new Error(
+      `WebGPU device lost while waiting for submitted work (${info?.reason ?? "unknown"}).`
+    );
+  }) : null;
+  const startedAtMs = nowMs3();
+  while (true) {
+    const elapsedMs = Math.max(0, nowMs3() - startedAtMs);
+    const remainingMs = Math.max(0, maxWaitMs - elapsedMs);
+    if (remainingMs <= 0) {
+      if (!allowTimeout) {
+        throw new Error(`Timed out after ${Math.round(maxWaitMs)} ms waiting for submitted GPU work.`);
+      }
+      console.warn(
+        `[plasius.wavefront] Submitted GPU work did not report completion within ${Math.round(maxWaitMs)} ms; continuing.`
+      );
       return false;
     }
-    for (let component = 0; component < 3; component += 1) {
-      if ((leftMedium?.absorption?.[component] ?? 0) !== (rightMedium?.absorption?.[component] ?? 0)) {
-        return false;
+    const waitWindowMs = Math.max(1, Math.min(timeoutMs, remainingMs));
+    let timeoutHandle = null;
+    let resolveTimeoutPromise = null;
+    let timeoutSettled = false;
+    const settleTimeoutPromise = (value) => {
+      if (timeoutSettled) {
+        return;
       }
-      if ((leftMedium?.scattering?.[component] ?? 0) !== (rightMedium?.scattering?.[component] ?? 0)) {
-        return false;
+      timeoutSettled = true;
+      resolveTimeoutPromise?.(value);
+    };
+    const timeoutPromise = new Promise((resolve) => {
+      resolveTimeoutPromise = resolve;
+      timeoutHandle = setTimeout(
+        () => settleTimeoutPromise({ status: "timeout" }),
+        waitWindowMs
+      );
+    });
+    let result;
+    try {
+      result = await Promise.race(
+        [completionPromise, timeoutPromise, lossPromise].filter(Boolean)
+      );
+    } finally {
+      if (timeoutHandle !== null) {
+        clearTimeout(timeoutHandle);
+        settleTimeoutPromise({ status: "cancelled" });
+      }
+    }
+    if (result?.status === "done") {
+      return true;
+    }
+    if (result?.status !== "timeout") {
+      return true;
+    }
+  }
+}
+
+// src/wavefront-upload.js
+async function uploadWavefrontBuffer(device, buffer, data, { chunkBytes = 8 * 1024 * 1024 } = {}) {
+  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 4 || chunkBytes % 4 !== 0) throw new Error("GPU upload chunk size must be a positive multiple of four.");
+  if (data.byteLength <= chunkBytes) {
+    device.queue.writeBuffer(buffer, 0, data);
+    return;
+  }
+  for (let offset = 0; offset < data.byteLength; offset += chunkBytes) {
+    device.queue.writeBuffer(buffer, offset, data, offset, Math.min(chunkBytes, data.byteLength - offset));
+    await waitForSubmittedGpuWork(device, { timeoutMs: 1e4, maxWaitMs: 1e4, allowTimeout: false });
+  }
+}
+
+// src/gpu-allocation-budget.js
+var formats = Object.freeze({
+  r8unorm: 1,
+  r8snorm: 1,
+  r8uint: 1,
+  r8sint: 1,
+  rg8unorm: 2,
+  rg8snorm: 2,
+  rg8uint: 2,
+  rg8sint: 2,
+  r16float: 2,
+  r16uint: 2,
+  r16sint: 2,
+  rgba8unorm: 4,
+  "rgba8unorm-srgb": 4,
+  bgra8unorm: 4,
+  "bgra8unorm-srgb": 4,
+  rgba8snorm: 4,
+  rgba8uint: 4,
+  rgba8sint: 4,
+  rg16float: 4,
+  rg16uint: 4,
+  rg16sint: 4,
+  r32float: 4,
+  r32uint: 4,
+  r32sint: 4,
+  rgb10a2unorm: 4,
+  rg11b10ufloat: 4,
+  rgba16float: 8,
+  rgba16uint: 8,
+  rgba16sint: 8,
+  rg32float: 8,
+  rg32uint: 8,
+  rg32sint: 8,
+  rgba32float: 16,
+  rgba32uint: 16,
+  rgba32sint: 16
+});
+function integer(value, name, minimum = 1) {
+  if (!Number.isSafeInteger(value) || value < minimum) throw new Error(`${name} must be a safe integer >= ${minimum}.`);
+  return value;
+}
+function within(value, limit, name) {
+  if (Number.isFinite(limit) && value > limit) throw new Error(`GPU ${name} limit exceeded: requested ${value}, available ${limit}.`);
+}
+function textureBytes(descriptor, limits) {
+  const size = descriptor.size;
+  const array = Array.isArray(size) || ArrayBuffer.isView(size);
+  const width = integer(array ? size[0] : size?.width, "Texture width");
+  const height = integer((array ? size[1] : size?.height) ?? 1, "Texture height");
+  const layers = integer((array ? size[2] : size?.depthOrArrayLayers) ?? 1, "Texture depth/layers");
+  const dimension2 = descriptor.dimension ?? "2d";
+  if (!["1d", "2d", "3d"].includes(dimension2)) throw new Error("Unsupported GPU texture dimension.");
+  const limit = limits[dimension2 === "3d" ? "maxTextureDimension3D" : dimension2 === "1d" ? "maxTextureDimension1D" : "maxTextureDimension2D"];
+  within(Math.max(width, height, dimension2 === "3d" ? layers : 1), limit, "texture dimension");
+  if (dimension2 !== "3d") within(layers, limits.maxTextureArrayLayers, "texture layers");
+  const bpp = formats[descriptor.format];
+  if (!bpp) throw new Error(`GPU memory accounting does not support texture format ${descriptor.format}.`);
+  const levels = integer(descriptor.mipLevelCount ?? 1, "Mip count");
+  const samples = integer(descriptor.sampleCount ?? 1, "Sample count");
+  if (levels > Math.floor(Math.log2(Math.max(width, height, dimension2 === "3d" ? layers : 1))) + 1) throw new Error("Invalid texture mip count.");
+  let bytes = 0;
+  for (let level = 0; level < levels; level++) bytes += Math.max(1, Math.floor(width / 2 ** level)) * Math.max(1, Math.floor(height / 2 ** level)) * (dimension2 === "3d" ? Math.max(1, Math.floor(layers / 2 ** level)) : layers) * bpp * samples;
+  return integer(bytes, "Texture allocation");
+}
+function createGpuAllocationTracker(rawDevice, { budgetBytes, storageUsage = globalThis.GPUBufferUsage?.STORAGE ?? 128 } = {}) {
+  if (budgetBytes !== void 0) integer(budgetBytes, "GPU memory budget");
+  const records = /* @__PURE__ */ new Map();
+  let allocatedBytes = 0, peakAllocatedBytes = 0;
+  function allocate(kind, descriptor, bytes, create) {
+    integer(bytes, "GPU allocation", 0);
+    const total = integer(allocatedBytes + bytes, "GPU allocation total", 0);
+    if (budgetBytes !== void 0 && total > budgetBytes) throw new Error(`GPU memory budget exceeded: ${total} requested bytes, budget ${budgetBytes}. Reduce quality or scene resources.`);
+    const resource = create(descriptor), originalDestroy = resource.destroy.bind(resource);
+    const release = () => {
+      if (!records.has(resource)) return;
+      originalDestroy();
+      records.delete(resource);
+      allocatedBytes -= bytes;
+    };
+    try {
+      Object.defineProperty(resource, "destroy", { value: release, configurable: true });
+    } catch (error) {
+      originalDestroy();
+      throw error;
+    }
+    records.set(resource, { kind, label: descriptor.label ?? "", bytes, release });
+    allocatedBytes = total;
+    peakAllocatedBytes = Math.max(total, peakAllocatedBytes);
+    return resource;
+  }
+  const destroy = () => {
+    for (const record of [...records.values()]) record.release();
+  };
+  const methods = {
+    createBuffer(descriptor) {
+      const bytes = integer(descriptor.size, "Buffer size", 0);
+      within(bytes, rawDevice.limits?.maxBufferSize, "buffer size");
+      if ((descriptor.usage ?? 0) & storageUsage) within(bytes, rawDevice.limits?.maxStorageBufferBindingSize, "storage binding size");
+      return allocate("buffer", descriptor, bytes, (d) => rawDevice.createBuffer(d));
+    },
+    createTexture(descriptor) {
+      return allocate("texture", descriptor, textureBytes(descriptor, rawDevice.limits ?? {}), (d) => rawDevice.createTexture(d));
+    },
+    createQuerySet(descriptor) {
+      return allocate("query-set", descriptor, integer(descriptor.count, "Query count") * 8, (d) => rawDevice.createQuerySet(d));
+    },
+    destroy() {
+      destroy();
+      rawDevice.destroy();
+    }
+  };
+  const device = new Proxy(rawDevice, { get(target, key) {
+    if (Object.hasOwn(methods, key)) return methods[key];
+    const value = Reflect.get(target, key, target);
+    return typeof value === "function" ? value.bind(target) : value;
+  } });
+  return Object.freeze({ device, destroy, snapshot: () => Object.freeze({
+    accounting: "requested-resource-bytes",
+    budgetBytes: budgetBytes ?? null,
+    allocatedBytes,
+    peakAllocatedBytes,
+    resources: Object.freeze([...records.values()].map(({ kind, label, bytes }) => Object.freeze({ kind, label, bytes })))
+  }) });
+}
+function openGpuAllocationErrorScopes(device) {
+  if (typeof device.pushErrorScope !== "function" || typeof device.popErrorScope !== "function") return async () => {
+  };
+  let count = 0;
+  try {
+    device.pushErrorScope("out-of-memory");
+    count++;
+    device.pushErrorScope("validation");
+    count++;
+  } catch (error) {
+    while (count-- > 0) Promise.resolve(device.popErrorScope()).catch(() => {
+    });
+    throw error;
+  }
+  return async () => {
+    const completions = [];
+    while (count > 0) {
+      count--;
+      try {
+        completions.push(Promise.resolve(device.popErrorScope()));
+      } catch (error) {
+        completions.push(Promise.reject(error));
       }
     }
-  }
-  return true;
+    if (!completions.length) return;
+    let timer;
+    try {
+      const errors = await Promise.race([Promise.all(completions), new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("GPU allocation validation timed out.")), 1e4);
+      })]);
+      const error = errors.find(Boolean);
+      if (error) throw new Error(`GPU allocation failed: ${error.message ?? String(error)}`);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
 }
-function createAtlasTextureResource(device, constants, atlas, label) {
-  const upload = createRgba8TextureUpload(atlas);
-  const texture = device.createTexture({
-    label,
-    size: { width: upload.width, height: upload.height },
-    format: "rgba8unorm",
-    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
-  });
-  device.queue.writeTexture(
-    { texture },
-    upload.bytes,
-    { bytesPerRow: upload.bytesPerRow, rowsPerImage: upload.height },
-    { width: upload.width, height: upload.height, depthOrArrayLayers: 1 }
+
+// src/wavefront-sampling.js
+function buildOrthonormalBasis(normal) {
+  const tangentFallback = Math.abs(normal[1]) < 0.999 ? [0, 1, 0] : [1, 0, 0];
+  const tangent = normalize(cross2(tangentFallback, normal), [1, 0, 0]);
+  const bitangent = normalize(cross2(normal, tangent), [0, 0, 1]);
+  return { tangent, bitangent };
+}
+function localToWorld(local, normal) {
+  const basis = buildOrthonormalBasis(normal);
+  return normalize(
+    add(
+      add(scale(basis.tangent, local[0]), scale(basis.bitangent, local[1])),
+      scale(normal, local[2])
+    ),
+    normal
   );
-  return Object.freeze({
-    texture,
-    view: texture.createView(),
-    ownsTexture: true
-  });
 }
-
-// src/wavefront-runtime-support.js
-var WEBGPU_DEFAULT_MAX_STORAGE_BUFFER_BINDING_SIZE = 128 * 1024 * 1024;
-var WEBGPU_DEFAULT_MAX_BUFFER_SIZE = 256 * 1024 * 1024;
-function readRequestedDeviceLimit(source, name) {
-  const rawValue = source?.[name];
-  if (rawValue === void 0 || rawValue === null) {
-    return 0;
-  }
-  const value = Number(rawValue);
-  if (!Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`${name} must be a non-negative safe integer.`);
-  }
-  return value;
+function radicalInverseVdc(bits) {
+  let value = bits >>> 0;
+  value = (value << 16 | value >>> 16) >>> 0;
+  value = ((value & 1431655765) << 1 | (value & 2863311530) >>> 1) >>> 0;
+  value = ((value & 858993459) << 2 | (value & 3435973836) >>> 2) >>> 0;
+  value = ((value & 252645135) << 4 | (value & 4042322160) >>> 4) >>> 0;
+  value = ((value & 16711935) << 8 | (value & 4278255360) >>> 8) >>> 0;
+  return value * 23283064365386963e-26;
 }
-function assertAdapterSupportsRequiredLimit(adapter, name, requiredValue) {
-  const availableValue = Number(adapter?.limits?.[name]);
-  if (!Number.isFinite(availableValue)) {
-    throw new Error(
-      `Wavefront scene buffers require ${name}>=${requiredValue} bytes, but this adapter does not expose that limit.`
-    );
-  }
-  if (availableValue < requiredValue) {
-    throw new Error(
-      `Wavefront scene buffers require ${name}>=${requiredValue} bytes, but this adapter exposes ${availableValue} bytes.`
+function hammersley(index, count) {
+  return [index / Math.max(count, 1), radicalInverseVdc(index)];
+}
+function importanceSampleGgx(sample, roughness, normal) {
+  const alpha = Math.max(roughness * roughness, 1e-4);
+  const phi = 2 * Math.PI * sample[0];
+  const cosTheta = Math.sqrt((1 - sample[1]) / (1 + (alpha * alpha - 1) * sample[1]));
+  const sinTheta = Math.sqrt(Math.max(0, 1 - cosTheta * cosTheta));
+  const halfVector = localToWorld(
+    [Math.cos(phi) * sinTheta, Math.sin(phi) * sinTheta, cosTheta],
+    normal
+  );
+  return normalize(halfVector, normal);
+}
+function geometrySchlickGgx(nDotV, roughness) {
+  const k = (roughness + 1) * (roughness + 1) / 8;
+  return nDotV / Math.max(nDotV * (1 - k) + k, 1e-6);
+}
+function geometrySmith(nDotV, nDotL, roughness) {
+  return geometrySchlickGgx(nDotV, roughness) * geometrySchlickGgx(nDotL, roughness);
+}
+function integrateBrdfSample(nDotV, roughness, sampleCount) {
+  const viewDirection = [Math.sqrt(Math.max(0, 1 - nDotV * nDotV)), 0, nDotV];
+  const normal = [0, 0, 1];
+  let scaleTerm = 0;
+  let biasTerm = 0;
+  for (let index = 0; index < sampleCount; index += 1) {
+    const xi = hammersley(index, sampleCount);
+    const halfVector = importanceSampleGgx(xi, roughness, normal);
+    const vDotH = Math.max(dot(viewDirection, halfVector), 0);
+    const lightDirection = normalize(
+      subtract(scale(halfVector, 2 * vDotH), viewDirection),
+      normal
     );
+    const nDotL = Math.max(lightDirection[2], 0);
+    const nDotH = Math.max(halfVector[2], 0);
+    if (nDotL <= 0 || nDotH <= 0 || vDotH <= 0) {
+      continue;
+    }
+    const geometry = geometrySmith(nDotV, nDotL, roughness);
+    const visibility = geometry * vDotH / Math.max(nDotH * nDotV, 1e-6);
+    const fresnel2 = (1 - vDotH) ** 5;
+    scaleTerm += (1 - fresnel2) * visibility;
+    biasTerm += fresnel2 * visibility;
   }
+  return [scaleTerm / sampleCount, biasTerm / sampleCount];
 }
-function getGpuUsageConstants() {
-  if (typeof GPUBufferUsage === "undefined" || typeof GPUTextureUsage === "undefined" || typeof GPUShaderStage === "undefined") {
-    throw new Error("WebGPU runtime unavailable. Required GPU constants are missing.");
+
+// src/wavefront-gpu-resources.js
+function clampTileSizeForDevice(config, device) {
+  const limit = Number(device?.limits?.maxStorageBufferBindingSize);
+  if (!Number.isFinite(limit) || limit <= 0) {
+    return config.tileSize;
   }
-  if (typeof GPUBufferUsage.INDIRECT !== "number") {
-    throw new Error("WebGPU runtime unavailable. GPUBufferUsage.INDIRECT is missing.");
+  const maxPixelsByRay = Math.floor(limit / RAY_RECORD_BYTES);
+  const maxPixelsByHit = Math.floor(limit / HIT_RECORD_BYTES);
+  const maxPixelsByPathVertex = Math.floor(
+    limit / ((config.maxDepth + 1) * PATH_VERTEX_RECORD_BYTES)
+  );
+  const maxPixels = Math.max(
+    256,
+    Math.min(maxPixelsByRay, maxPixelsByHit, maxPixelsByPathVertex)
+  );
+  if (config.tilePixelCapacity <= maxPixels) {
+    return config.tileSize;
   }
-  return {
-    buffer: GPUBufferUsage,
-    texture: GPUTextureUsage,
-    shader: GPUShaderStage,
-    map: typeof GPUMapMode === "undefined" ? null : GPUMapMode
-  };
+  return Math.max(16, Math.floor(Math.sqrt(maxPixels)));
 }
-function resolveCanvas3(canvasOrSelector, documentRef = globalThis.document) {
-  if (typeof canvasOrSelector === "string") {
-    const resolved = documentRef?.querySelector?.(canvasOrSelector);
-    if (!resolved) {
-      throw new Error(`Unable to find canvas for selector: ${canvasOrSelector}`);
-    }
-    return resolved;
+function createBuffer(device, usage, size, label) {
+  return device.createBuffer({
+    label,
+    size: Math.max(4, size),
+    usage
+  });
+}
+function alignTo(value, alignment) {
+  const resolvedAlignment = Math.max(1, alignment);
+  return Math.ceil(value / resolvedAlignment) * resolvedAlignment;
+}
+function float32ToFloat16Bits(value) {
+  const floatView = new Float32Array(1);
+  const intView = new Uint32Array(floatView.buffer);
+  floatView[0] = Number.isFinite(value) ? value : 0;
+  const x = intView[0];
+  const sign = x >> 16 & 32768;
+  let mantissa = x & 8388607;
+  let exponent = x >> 23 & 255;
+  if (exponent === 255) {
+    return sign | (mantissa ? 32256 : 31744);
   }
-  if (canvasOrSelector?.getContext) {
-    return canvasOrSelector;
+  exponent = exponent - 127 + 15;
+  if (exponent >= 31) {
+    return sign | 31744;
   }
-  const fallback = documentRef?.querySelector?.("canvas[data-plasius-wavefront-path-tracing]");
-  if (!fallback) {
-    throw new Error("A canvas is required for WebGPU wavefront path tracing.");
+  if (exponent <= 0) {
+    if (exponent < -10) {
+      return sign;
+    }
+    mantissa = (mantissa | 8388608) >> 1 - exponent;
+    return sign | mantissa + 4096 >> 13;
   }
-  return fallback;
+  return sign | exponent << 10 | mantissa + 4096 >> 13;
 }
-async function getPipelineDiagnostics(shaderModule) {
-  if (typeof shaderModule?.getCompilationInfo !== "function") {
-    return "";
+function environmentMapIntegerScale(data) {
+  if (data instanceof Uint8Array) {
+    return 1 / 255;
   }
-  try {
-    const info = await shaderModule.getCompilationInfo();
-    const messages = info.messages ?? [];
-    if (messages.length === 0) {
-      return "";
-    }
-    return messages.map((message) => {
-      const line = message.lineNum ?? "?";
-      const column = message.linePos ?? "?";
-      return `line ${line}:${column} ${message.message}`;
-    }).join("\n");
-  } catch {
-    return "";
+  if (data instanceof Uint16Array) {
+    return 1 / 65535;
   }
+  return 1;
 }
-async function createComputePipeline(device, shaderModule, layout, entryPoint, label) {
-  const descriptor = {
-    label,
-    layout,
-    compute: {
-      module: shaderModule,
-      entryPoint
-    }
-  };
-  try {
-    if (typeof device.createComputePipelineAsync === "function") {
-      return await device.createComputePipelineAsync(descriptor);
-    }
-    return device.createComputePipeline(descriptor);
-  } catch (error) {
-    const diagnostics = await getPipelineDiagnostics(shaderModule);
-    const suffix = diagnostics ? `
-${diagnostics}` : "";
-    throw new Error(`WGSL compilation failed for ${label}: ${error.message}${suffix}`, {
-      cause: error
-    });
+function environmentMapHasSamplingData(environmentMap) {
+  if (!environmentMap || !environmentMap.data) {
+    return false;
+  }
+  const width = Math.max(1, environmentMap.width ?? 1);
+  const height = Math.max(1, environmentMap.height ?? 1);
+  return environmentMap.data.length >= width * height * 4;
+}
+function createRgba8TextureUpload(source) {
+  const width = Math.max(1, Math.trunc(source.width));
+  const height = Math.max(1, Math.trunc(source.height));
+  const bytesPerRow = alignTo(width * 4, 256);
+  const bytes = new Uint8Array(bytesPerRow * height);
+  const data = source.data instanceof Uint8Array ? source.data : new Uint8Array(source.data);
+  for (let y = 0; y < height; y += 1) {
+    const sourceOffset = y * width * 4;
+    const targetOffset = y * bytesPerRow;
+    bytes.set(data.subarray(sourceOffset, sourceOffset + width * 4), targetOffset);
+  }
+  return Object.freeze({
+    bytes,
+    bytesPerRow,
+    width,
+    height
+  });
+}
+function readEnvironmentMapComponent(data, index, fallback, integerScale = 1) {
+  if (!data || index >= data.length) {
+    return fallback;
   }
+  const value = Number(data[index]);
+  return Number.isFinite(value) ? Math.max(0, value) * integerScale : fallback;
 }
-async function assertShaderModuleCompiles(shaderModule, label) {
-  if (typeof shaderModule?.getCompilationInfo !== "function") {
-    return;
+function createBrdfLutUploadBytes(size = DEFAULT_BRDF_LUT_SIZE, sampleCount = DEFAULT_BRDF_LUT_SAMPLE_COUNT) {
+  const cacheKey = `${Math.max(1, Math.trunc(size))}:${Math.max(1, Math.trunc(sampleCount))}`;
+  const cached = BRDF_LUT_UPLOAD_CACHE.get(cacheKey);
+  if (cached) {
+    return cached;
   }
-  const info = await shaderModule.getCompilationInfo();
-  const messages = Array.isArray(info?.messages) ? info.messages : [];
-  const errors = messages.filter((message) => message?.type === "error");
-  if (errors.length <= 0) {
-    return;
+  const width = Math.max(1, Math.trunc(size));
+  const height = Math.max(1, Math.trunc(size));
+  const rowBytes = width * 8;
+  const bytesPerRow = alignTo(rowBytes, 256);
+  const bytes = new Uint8Array(bytesPerRow * height);
+  const view = new DataView(bytes.buffer);
+  for (let y = 0; y < height; y += 1) {
+    const roughness = (y + 0.5) / height;
+    for (let x = 0; x < width; x += 1) {
+      const nDotV = Math.max((x + 0.5) / width, 1e-4);
+      const [scaleTerm, biasTerm] = integrateBrdfSample(nDotV, roughness, sampleCount);
+      const offset = y * bytesPerRow + x * 8;
+      view.setUint16(offset, float32ToFloat16Bits(scaleTerm), true);
+      view.setUint16(offset + 2, float32ToFloat16Bits(biasTerm), true);
+      view.setUint16(offset + 4, float32ToFloat16Bits(0), true);
+      view.setUint16(offset + 6, float32ToFloat16Bits(1), true);
+    }
   }
-  const diagnostics = errors.map((message) => {
-    const line = Number.isFinite(message.lineNum) ? message.lineNum : "?";
-    const column = Number.isFinite(message.linePos) ? message.linePos : "?";
-    return `line ${line}:${column} ${message.message}`;
-  }).join("\n");
-  throw new Error(`WGSL compilation preflight failed for ${label}:
-${diagnostics}`);
+  const upload = Object.freeze({ bytes, bytesPerRow, width, height });
+  BRDF_LUT_UPLOAD_CACHE.set(cacheKey, upload);
+  return upload;
 }
-async function createRenderPipeline(device, descriptor) {
-  if (typeof device.createRenderPipelineAsync === "function") {
-    return device.createRenderPipelineAsync(descriptor);
+function createLinearEnvironmentPixels(environmentMap, fallbackColor) {
+  const width = Math.max(1, environmentMap.width);
+  const height = Math.max(1, environmentMap.height);
+  const pixels = new Float32Array(width * height * 4);
+  const data = environmentMap.data;
+  const integerScale = environmentMapIntegerScale(data);
+  for (let index = 0; index < width * height; index += 1) {
+    const sourceOffset = index * 4;
+    const targetOffset = index * 4;
+    pixels[targetOffset] = readEnvironmentMapComponent(data, sourceOffset, fallbackColor[0], integerScale);
+    pixels[targetOffset + 1] = readEnvironmentMapComponent(data, sourceOffset + 1, fallbackColor[1], integerScale);
+    pixels[targetOffset + 2] = readEnvironmentMapComponent(data, sourceOffset + 2, fallbackColor[2], integerScale);
+    pixels[targetOffset + 3] = readEnvironmentMapComponent(data, sourceOffset + 3, fallbackColor[3] ?? 1, integerScale);
   }
-  return device.createRenderPipeline(descriptor);
+  return pixels;
 }
-function createWavefrontDeviceDescriptor(adapter, options = {}, memory = null) {
-  const descriptor = { ...options.deviceDescriptor ?? {} };
-  const descriptorRequiredLimits = { ...descriptor.requiredLimits ?? {} };
-  const requiredLimits = {
-    ...descriptorRequiredLimits,
-    ...options.requiredLimits ?? {}
+function environmentUvToDirection(u, v, rotationRadians = 0) {
+  const angle = (u - rotationRadians / (2 * Math.PI) - 0.5) * 2 * Math.PI;
+  const theta = v * Math.PI;
+  const sinTheta = Math.sin(theta);
+  return [
+    Math.cos(angle) * sinTheta,
+    Math.cos(theta),
+    Math.sin(angle) * sinTheta
+  ];
+}
+function sampleEnvironmentPixelsBilinear(pixels, width, height, u, v) {
+  const wrappedU = (u % 1 + 1) % 1;
+  const clampedV = clamp2(v, 0, 1);
+  const x = wrappedU * width - 0.5;
+  const y = clampedV * height - 0.5;
+  const x0 = (Math.floor(x) % width + width) % width;
+  const y0 = clamp2(Math.floor(y), 0, height - 1);
+  const x1 = (x0 + 1) % width;
+  const y1 = clamp2(y0 + 1, 0, height - 1);
+  const tx = x - Math.floor(x);
+  const ty = y - Math.floor(y);
+  const read = (px, py) => {
+    const offset = (py * width + px) * 4;
+    return [pixels[offset], pixels[offset + 1], pixels[offset + 2], pixels[offset + 3]];
   };
-  const exposedStorageBufferLimit = Number(adapter?.limits?.maxStorageBuffersPerShaderStage);
-  if (Number.isFinite(exposedStorageBufferLimit)) {
-    if (exposedStorageBufferLimit < TRACE_STORAGE_BUFFER_BINDINGS) {
-      throw new Error(
-        `Wavefront mesh tracing requires maxStorageBuffersPerShaderStage>=${TRACE_STORAGE_BUFFER_BINDINGS}, but this adapter exposes ${exposedStorageBufferLimit}.`
-      );
+  const a = read(x0, y0);
+  const b = read(x1, y0);
+  const c = read(x0, y1);
+  const d = read(x1, y1);
+  const mixPair = (first, second, factor) => first * (1 - factor) + second * factor;
+  return [
+    mixPair(mixPair(a[0], b[0], tx), mixPair(c[0], d[0], tx), ty),
+    mixPair(mixPair(a[1], b[1], tx), mixPair(c[1], d[1], tx), ty),
+    mixPair(mixPair(a[2], b[2], tx), mixPair(c[2], d[2], tx), ty),
+    mixPair(mixPair(a[3], b[3], tx), mixPair(c[3], d[3], tx), ty)
+  ];
+}
+function directionToEnvironmentUv(direction, rotationRadians = 0) {
+  const unitDirection = normalize(direction, [0, 1, 0]);
+  const rotationTurns = rotationRadians / (2 * Math.PI);
+  const u = ((Math.atan2(unitDirection[2], unitDirection[0]) / (2 * Math.PI) + 0.5 + rotationTurns) % 1 + 1) % 1;
+  const v = Math.acos(clamp2(unitDirection[1], -1, 1)) / Math.PI;
+  return [u, clamp2(v, 0, 1)];
+}
+function sampleEnvironmentRadiance(pixels, width, height, direction, rotationRadians = 0) {
+  const [u, v] = directionToEnvironmentUv(direction, rotationRadians);
+  return sampleEnvironmentPixelsBilinear(pixels, width, height, u, v);
+}
+function createFloat16RgbaUploadFromLevels(levels) {
+  return levels.map((level) => {
+    const rowBytes = level.width * 8;
+    const bytesPerRow = alignTo(rowBytes, 256);
+    const bytes = new Uint8Array(bytesPerRow * level.height);
+    const view = new DataView(bytes.buffer);
+    for (let y = 0; y < level.height; y += 1) {
+      for (let x = 0; x < level.width; x += 1) {
+        const sourceOffset = (y * level.width + x) * 4;
+        const targetOffset = y * bytesPerRow + x * 8;
+        view.setUint16(targetOffset, float32ToFloat16Bits(level.data[sourceOffset]), true);
+        view.setUint16(targetOffset + 2, float32ToFloat16Bits(level.data[sourceOffset + 1]), true);
+        view.setUint16(targetOffset + 4, float32ToFloat16Bits(level.data[sourceOffset + 2]), true);
+        view.setUint16(targetOffset + 6, float32ToFloat16Bits(level.data[sourceOffset + 3]), true);
+      }
     }
-    requiredLimits.maxStorageBuffersPerShaderStage = Math.max(
-      Number(requiredLimits.maxStorageBuffersPerShaderStage ?? 0),
-      TRACE_STORAGE_BUFFER_BINDINGS
-    );
-  }
-  const exposedSampledTextureLimit = Number(adapter?.limits?.maxSampledTexturesPerShaderStage);
-  if (Number.isFinite(exposedSampledTextureLimit)) {
-    if (exposedSampledTextureLimit < TRACE_SAMPLED_TEXTURE_BINDINGS) {
-      throw new Error(
-        `Wavefront material tracing requires maxSampledTexturesPerShaderStage>=${TRACE_SAMPLED_TEXTURE_BINDINGS}, but this adapter exposes ${exposedSampledTextureLimit}.`
-      );
+    return Object.freeze({ bytes, bytesPerRow, width: level.width, height: level.height });
+  });
+}
+function createPrefilteredEnvironmentLevels(environmentMap, fallbackColor) {
+  const sourcePixels = createLinearEnvironmentPixels(environmentMap, fallbackColor);
+  const sourceWidth = Math.max(1, environmentMap.width);
+  const sourceHeight = Math.max(1, environmentMap.height);
+  const mipLevelCount = Math.max(1, Math.floor(Math.log2(Math.max(sourceWidth, sourceHeight))) + 1);
+  const levels = [
+    Object.freeze({
+      width: sourceWidth,
+      height: sourceHeight,
+      data: sourcePixels
+    })
+  ];
+  for (let mipLevel = 1; mipLevel < mipLevelCount; mipLevel += 1) {
+    const width = Math.max(1, sourceWidth >> mipLevel);
+    const height = Math.max(1, sourceHeight >> mipLevel);
+    const roughness = mipLevelCount <= 1 ? 0 : mipLevel / (mipLevelCount - 1);
+    const data = new Float32Array(width * height * 4);
+    const sampleCount = roughness < 0.25 ? 64 : roughness < 0.6 ? 96 : 128;
+    for (let y = 0; y < height; y += 1) {
+      for (let x = 0; x < width; x += 1) {
+        const direction = environmentUvToDirection((x + 0.5) / width, (y + 0.5) / height, environmentMap.rotationRadians);
+        const normal = normalize(direction, [0, 1, 0]);
+        const viewDirection = normal;
+        let totalWeight = 0;
+        const accum = [0, 0, 0];
+        for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex += 1) {
+          const xi = hammersley(sampleIndex, sampleCount);
+          const halfVector = importanceSampleGgx(xi, roughness, normal);
+          const viewDotHalf = Math.max(dot(viewDirection, halfVector), 0);
+          const lightDirection = normalize(
+            subtract(scale(halfVector, 2 * viewDotHalf), viewDirection),
+            normal
+          );
+          const nDotL = Math.max(dot(normal, lightDirection), 0);
+          if (nDotL <= 1e-6) {
+            continue;
+          }
+          const radiance = sampleEnvironmentRadiance(
+            sourcePixels,
+            sourceWidth,
+            sourceHeight,
+            lightDirection,
+            environmentMap.rotationRadians
+          );
+          accum[0] += radiance[0] * nDotL;
+          accum[1] += radiance[1] * nDotL;
+          accum[2] += radiance[2] * nDotL;
+          totalWeight += nDotL;
+        }
+        const offset = (y * width + x) * 4;
+        data[offset] = accum[0] / Math.max(totalWeight, 1e-6);
+        data[offset + 1] = accum[1] / Math.max(totalWeight, 1e-6);
+        data[offset + 2] = accum[2] / Math.max(totalWeight, 1e-6);
+        data[offset + 3] = 1;
+      }
     }
-    requiredLimits.maxSampledTexturesPerShaderStage = Math.max(
-      Number(requiredLimits.maxSampledTexturesPerShaderStage ?? 0),
-      TRACE_SAMPLED_TEXTURE_BINDINGS
-    );
-  }
-  const sceneStorageBufferBindingBytes = Number(
-    memory?.sceneStorageBufferBindingBytes ?? 0
-  );
-  const requestedStorageBufferBindingSize = Math.max(
-    readRequestedDeviceLimit(descriptorRequiredLimits, "maxStorageBufferBindingSize"),
-    readRequestedDeviceLimit(options.requiredLimits, "maxStorageBufferBindingSize"),
-    sceneStorageBufferBindingBytes > WEBGPU_DEFAULT_MAX_STORAGE_BUFFER_BINDING_SIZE ? sceneStorageBufferBindingBytes : 0
-  );
-  if (requestedStorageBufferBindingSize > 0) {
-    assertAdapterSupportsRequiredLimit(
-      adapter,
-      "maxStorageBufferBindingSize",
-      requestedStorageBufferBindingSize
-    );
-    requiredLimits.maxStorageBufferBindingSize = requestedStorageBufferBindingSize;
-  }
-  const requestedMaxBufferSize = Math.max(
-    readRequestedDeviceLimit(descriptorRequiredLimits, "maxBufferSize"),
-    readRequestedDeviceLimit(options.requiredLimits, "maxBufferSize"),
-    sceneStorageBufferBindingBytes > WEBGPU_DEFAULT_MAX_BUFFER_SIZE ? sceneStorageBufferBindingBytes : 0,
-    requestedStorageBufferBindingSize > WEBGPU_DEFAULT_MAX_BUFFER_SIZE ? requestedStorageBufferBindingSize : 0
-  );
-  if (requestedMaxBufferSize > 0) {
-    assertAdapterSupportsRequiredLimit(adapter, "maxBufferSize", requestedMaxBufferSize);
-    requiredLimits.maxBufferSize = requestedMaxBufferSize;
+    levels.push(Object.freeze({ width, height, data }));
   }
-  const requiredFeatures = Array.from(descriptor.requiredFeatures ?? []);
-  const adapterFeatures = adapter?.features;
-  const timestampQuerySupported = typeof adapterFeatures?.has === "function" ? adapterFeatures.has("timestamp-query") : adapterFeatures && typeof adapterFeatures[Symbol.iterator] === "function" ? Array.from(adapterFeatures).includes("timestamp-query") : false;
-  if (options.gpuTimestamps !== false && timestampQuerySupported && !requiredFeatures.includes("timestamp-query")) {
-    requiredFeatures.push("timestamp-query");
+  return Object.freeze({
+    levels,
+    mipLevelCount,
+    width: sourceWidth,
+    height: sourceHeight
+  });
+}
+function createEnvironmentSamplingTables(environmentMap, fallbackColor) {
+  if (!environmentMapHasSamplingData(environmentMap)) {
+    return Object.freeze({
+      width: 1,
+      height: 1,
+      pdf: new Float32Array([1]),
+      marginalCdf: new Float32Array([1]),
+      conditionalCdf: new Float32Array([1]),
+      hasImportanceData: false
+    });
   }
-  if (requiredFeatures.length > 0) {
-    descriptor.requiredFeatures = requiredFeatures;
+  const pixels = createLinearEnvironmentPixels(environmentMap, fallbackColor);
+  const width = Math.max(1, environmentMap.width);
+  const height = Math.max(1, environmentMap.height);
+  const pdf = new Float32Array(width * height);
+  const marginalCdf = new Float32Array(height);
+  const conditionalCdf = new Float32Array(width * height);
+  const rowSums = new Float32Array(height);
+  let totalWeight = 0;
+  for (let y = 0; y < height; y += 1) {
+    const theta = (y + 0.5) / height * Math.PI;
+    const sinTheta = Math.max(Math.sin(theta), 1e-4);
+    let rowWeight = 0;
+    for (let x = 0; x < width; x += 1) {
+      const offset = (y * width + x) * 4;
+      const luminance = pixels[offset] * 0.2126 + pixels[offset + 1] * 0.7152 + pixels[offset + 2] * 0.0722;
+      const weight = Math.max(luminance * sinTheta, 1e-6);
+      pdf[y * width + x] = weight;
+      rowWeight += weight;
+      conditionalCdf[y * width + x] = rowWeight;
+    }
+    rowSums[y] = rowWeight;
+    totalWeight += rowWeight;
+    if (rowWeight > 0) {
+      for (let x = 0; x < width; x += 1) {
+        conditionalCdf[y * width + x] /= rowWeight;
+      }
+    } else {
+      for (let x = 0; x < width; x += 1) {
+        conditionalCdf[y * width + x] = (x + 1) / width;
+      }
+    }
+    marginalCdf[y] = totalWeight;
   }
-  if (Object.keys(requiredLimits).length > 0) {
-    descriptor.requiredLimits = {
-      ...descriptor.requiredLimits ?? {},
-      ...requiredLimits
-    };
+  for (let y = 0; y < height; y += 1) {
+    marginalCdf[y] /= Math.max(totalWeight, 1e-6);
   }
-  return Object.keys(descriptor).length > 0 ? descriptor : void 0;
+  for (let index = 0; index < pdf.length; index += 1) {
+    pdf[index] /= Math.max(totalWeight, 1e-6);
+  }
+  return Object.freeze({
+    width,
+    height,
+    pdf,
+    marginalCdf,
+    conditionalCdf,
+    hasImportanceData: true
+  });
 }
-function readGpuLimit(adapter, device, name) {
-  const adapterValue = Number(adapter?.limits?.[name]);
-  if (Number.isFinite(adapterValue)) {
-    return adapterValue;
+function createEnvironmentMapResource(device, constants, environmentMap, fallbackColor) {
+  if (environmentMap.view) {
+    return Object.freeze({
+      view: environmentMap.view,
+      sampler: environmentMap.sampler ?? device.createSampler({
+        label: "plasius.wavefront.environmentMapSampler",
+        addressModeU: "repeat",
+        addressModeV: "clamp-to-edge",
+        magFilter: "linear",
+        minFilter: "linear",
+        mipmapFilter: "linear"
+      }),
+      texture: null,
+      ownsTexture: false,
+      width: Math.max(1, environmentMap.width),
+      height: Math.max(1, environmentMap.height),
+      mipLevelCount: Math.max(1, environmentMap.mipLevelCount ?? 1)
+    });
   }
-  const deviceValue = Number(device?.limits?.[name]);
-  return Number.isFinite(deviceValue) ? deviceValue : null;
+  if (environmentMap.texture && typeof environmentMap.texture.createView === "function") {
+    return Object.freeze({
+      view: environmentMap.texture.createView(),
+      sampler: environmentMap.sampler ?? device.createSampler({
+        label: "plasius.wavefront.environmentMapSampler",
+        addressModeU: "repeat",
+        addressModeV: "clamp-to-edge",
+        magFilter: "linear",
+        minFilter: "linear",
+        mipmapFilter: "linear"
+      }),
+      texture: environmentMap.texture,
+      ownsTexture: false,
+      width: Math.max(1, environmentMap.width),
+      height: Math.max(1, environmentMap.height),
+      mipLevelCount: Math.max(1, environmentMap.mipLevelCount ?? 1)
+    });
+  }
+  const prefiltered = createPrefilteredEnvironmentLevels(environmentMap, fallbackColor);
+  const uploads = createFloat16RgbaUploadFromLevels(prefiltered.levels);
+  const texture = device.createTexture({
+    label: environmentMap.enabled ? "plasius.wavefront.environmentMap" : "plasius.wavefront.environmentMapFallback",
+    size: { width: prefiltered.width, height: prefiltered.height },
+    format: "rgba16float",
+    mipLevelCount: prefiltered.mipLevelCount,
+    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
+  });
+  uploads.forEach((upload, mipLevel) => {
+    device.queue.writeTexture(
+      { texture, mipLevel },
+      upload.bytes,
+      { bytesPerRow: upload.bytesPerRow, rowsPerImage: upload.height },
+      { width: upload.width, height: upload.height, depthOrArrayLayers: 1 }
+    );
+  });
+  return Object.freeze({
+    view: texture.createView(),
+    sampler: environmentMap.sampler ?? device.createSampler({
+      label: "plasius.wavefront.environmentMapSampler",
+      addressModeU: "repeat",
+      addressModeV: "clamp-to-edge",
+      magFilter: "linear",
+      minFilter: "linear",
+      mipmapFilter: "linear"
+    }),
+    texture,
+    ownsTexture: true,
+    width: prefiltered.width,
+    height: prefiltered.height,
+    mipLevelCount: prefiltered.mipLevelCount
+  });
 }
-function createAdapterInfoSnapshot(adapter) {
-  const info = adapter?.info;
-  if (!info || typeof info !== "object") {
-    return null;
+function createEnvironmentSamplingTextureResource(device, constants, environmentMap, fallbackColor) {
+  const tables = createEnvironmentSamplingTables(environmentMap, fallbackColor);
+  const rowBytes = tables.width * 8;
+  const bytesPerRow = alignTo(rowBytes, 256);
+  const bytes = new Uint8Array(bytesPerRow * tables.height);
+  const view = new DataView(bytes.buffer);
+  for (let y = 0; y < tables.height; y += 1) {
+    for (let x = 0; x < tables.width; x += 1) {
+      const probability = tables.pdf[y * tables.width + x];
+      const conditional = tables.conditionalCdf[y * tables.width + x];
+      const marginal = tables.marginalCdf[y];
+      const offset = y * bytesPerRow + x * 8;
+      view.setUint16(offset, float32ToFloat16Bits(probability), true);
+      view.setUint16(offset + 2, float32ToFloat16Bits(conditional), true);
+      view.setUint16(offset + 4, float32ToFloat16Bits(marginal), true);
+      view.setUint16(offset + 6, float32ToFloat16Bits(1), true);
+    }
   }
+  const texture = device.createTexture({
+    label: "plasius.wavefront.environmentSampling",
+    size: { width: tables.width, height: tables.height },
+    format: "rgba16float",
+    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
+  });
+  device.queue.writeTexture(
+    { texture },
+    bytes,
+    { bytesPerRow, rowsPerImage: tables.height },
+    { width: tables.width, height: tables.height, depthOrArrayLayers: 1 }
+  );
   return Object.freeze({
-    vendor: typeof info.vendor === "string" ? info.vendor : "",
-    architecture: typeof info.architecture === "string" ? info.architecture : "",
-    device: typeof info.device === "string" ? info.device : "",
-    description: typeof info.description === "string" ? info.description : ""
+    view: texture.createView(),
+    texture,
+    ownsTexture: true,
+    hasImportanceData: tables.hasImportanceData
   });
 }
-function createGpuAdapterParallelismDiagnostics(adapter, device) {
+function createBrdfLutResource(device, constants, size = DEFAULT_BRDF_LUT_SIZE) {
+  const upload = createBrdfLutUploadBytes(size);
+  const texture = device.createTexture({
+    label: "plasius.wavefront.brdfLut",
+    size: { width: upload.width, height: upload.height },
+    format: "rgba16float",
+    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
+  });
+  device.queue.writeTexture(
+    { texture },
+    upload.bytes,
+    { bytesPerRow: upload.bytesPerRow, rowsPerImage: upload.height },
+    { width: upload.width, height: upload.height, depthOrArrayLayers: 1 }
+  );
   return Object.freeze({
-    physicalCoreCount: null,
-    physicalCoreCountAvailable: false,
-    physicalCoreCountUnavailableReason: "WebGPU does not expose physical GPU core counts.",
-    adapterInfo: createAdapterInfoSnapshot(adapter),
-    adapterLimits: Object.freeze({
-      maxComputeInvocationsPerWorkgroup: readGpuLimit(adapter, device, "maxComputeInvocationsPerWorkgroup"),
-      maxComputeWorkgroupSizeX: readGpuLimit(adapter, device, "maxComputeWorkgroupSizeX"),
-      maxComputeWorkgroupSizeY: readGpuLimit(adapter, device, "maxComputeWorkgroupSizeY"),
-      maxComputeWorkgroupSizeZ: readGpuLimit(adapter, device, "maxComputeWorkgroupSizeZ"),
-      maxComputeWorkgroupsPerDimension: readGpuLimit(adapter, device, "maxComputeWorkgroupsPerDimension"),
-      maxStorageBuffersPerShaderStage: readGpuLimit(adapter, device, "maxStorageBuffersPerShaderStage"),
-      maxStorageBufferBindingSize: readGpuLimit(adapter, device, "maxStorageBufferBindingSize"),
-      maxBufferSize: readGpuLimit(adapter, device, "maxBufferSize")
+    view: texture.createView(),
+    sampler: device.createSampler({
+      label: "plasius.wavefront.brdfLutSampler",
+      addressModeU: "clamp-to-edge",
+      addressModeV: "clamp-to-edge",
+      magFilter: "linear",
+      minFilter: "linear"
     }),
-    configuredWorkgroupSize: WORKGROUP_SIZE
+    texture,
+    ownsTexture: true,
+    width: upload.width,
+    height: upload.height
   });
 }
-function createEnvironmentMapSnapshot(environmentMap) {
-  return Object.freeze({
-    enabled: environmentMap.enabled,
-    width: environmentMap.width,
-    height: environmentMap.height,
-    mipLevelCount: environmentMap.mipLevelCount ?? 1,
-    projection: environmentMap.projection,
-    intensity: environmentMap.intensity,
-    rotationRadians: environmentMap.rotationRadians,
-    ambientStrength: environmentMap.ambientStrength,
-    hasImportanceData: environmentMap.hasImportanceData === true
+function createMediumTextureResource(device, constants, mediums) {
+  const normalized = Array.isArray(mediums) && mediums.length > 0 ? mediums : [{ id: 0 }];
+  const width = Math.max(
+    1,
+    normalized.reduce((maximum, medium) => Math.max(maximum, medium.id ?? 0), 0) + 1
+  );
+  const level = {
+    width,
+    height: MEDIUM_TABLE_ROWS,
+    data: new Float32Array(width * MEDIUM_TABLE_ROWS * 4)
+  };
+  for (const medium of normalized) {
+    const mediumId = Math.max(0, Math.trunc(Number(medium.id) || 0));
+    const absorptionOffset = mediumId * 4;
+    level.data[absorptionOffset] = Math.max(0, medium.absorption?.[0] ?? 0);
+    level.data[absorptionOffset + 1] = Math.max(0, medium.absorption?.[1] ?? 0);
+    level.data[absorptionOffset + 2] = Math.max(0, medium.absorption?.[2] ?? 0);
+    level.data[absorptionOffset + 3] = Math.max(0, medium.phaseModel ?? 0);
+    const scatteringOffset = (width + mediumId) * 4;
+    level.data[scatteringOffset] = Math.max(0, medium.scattering?.[0] ?? 0);
+    level.data[scatteringOffset + 1] = Math.max(0, medium.scattering?.[1] ?? 0);
+    level.data[scatteringOffset + 2] = Math.max(0, medium.scattering?.[2] ?? 0);
+    level.data[scatteringOffset + 3] = Math.max(0, medium.density ?? 0);
+  }
+  const upload = createFloat16RgbaUploadFromLevels([level])[0];
+  const texture = device.createTexture({
+    label: "plasius.wavefront.mediumTable",
+    size: { width, height: MEDIUM_TABLE_ROWS },
+    format: "rgba16float",
+    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
+  });
+  device.queue.writeTexture(
+    { texture },
+    upload.bytes,
+    { bytesPerRow: upload.bytesPerRow, rowsPerImage: upload.height },
+    { width, height: MEDIUM_TABLE_ROWS, depthOrArrayLayers: 1 }
+  );
+  return Object.freeze({
+    texture,
+    view: texture.createView(),
+    ownsTexture: true,
+    count: normalized.length,
+    width
   });
 }
-function nowMs3() {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
+function mediumTablesEqual(left, right) {
+  const leftMediums = Array.isArray(left) ? left : [];
+  const rightMediums = Array.isArray(right) ? right : [];
+  if (leftMediums.length !== rightMediums.length) {
+    return false;
   }
-  return Date.now();
-}
-function estimateAccelerationBuildWaitFactor(config) {
-  if (config?.gpuAccelerationBuildRequired !== true) {
-    return 1;
+  for (let index = 0; index < leftMediums.length; index += 1) {
+    const leftMedium = leftMediums[index];
+    const rightMedium = rightMediums[index];
+    if ((leftMedium?.id ?? 0) !== (rightMedium?.id ?? 0)) {
+      return false;
+    }
+    if ((leftMedium?.phaseModel ?? 0) !== (rightMedium?.phaseModel ?? 0)) {
+      return false;
+    }
+    if ((leftMedium?.density ?? 0) !== (rightMedium?.density ?? 0)) {
+      return false;
+    }
+    for (let component = 0; component < 3; component += 1) {
+      if ((leftMedium?.absorption?.[component] ?? 0) !== (rightMedium?.absorption?.[component] ?? 0)) {
+        return false;
+      }
+      if ((leftMedium?.scattering?.[component] ?? 0) !== (rightMedium?.scattering?.[component] ?? 0)) {
+        return false;
+      }
+    }
   }
-  const bvhSortStageCount = Array.isArray(config?.bvhSortStages) ? config.bvhSortStages.length : 0;
-  const bvhBuildLevelCount = Array.isArray(config?.bvhBuildLevels) ? config.bvhBuildLevels.length : 0;
-  const accelerationStageCount = 2 + bvhSortStageCount + bvhBuildLevelCount;
-  return Math.max(1, 1 + accelerationStageCount / 96);
+  return true;
 }
-function estimateSubmittedGpuWorkTiming(config, tileCount, overrideTimeoutMs = null, options = {}) {
-  if (Number.isFinite(overrideTimeoutMs)) {
-    const overrideMs = Math.max(1, Math.trunc(Number(overrideTimeoutMs)));
-    return Object.freeze({
-      timeoutMs: overrideMs,
-      maxWaitMs: overrideMs
-    });
-  }
-  const samplesPerPixel = Math.max(
-    1,
-    Number(config?.renderedSamplesPerPixel ?? config?.samplesPerPixel ?? 1)
-  );
-  const maxDepth = Math.max(1, Number(config?.maxDepth ?? 1));
-  const deferredResolvePasses = config?.deferredPathResolve ? 1 : 0;
-  const denoisePasses = config?.denoise ? samplesPerPixel < 4 ? 2 : 1 : 0;
-  const tiles = Math.max(1, Number(tileCount ?? 1));
-  const estimatedPasses = tiles * (samplesPerPixel * (maxDepth + 1 + deferredResolvePasses) + denoisePasses + 1);
-  const triangleCount = Math.max(0, Number(config?.triangleCount ?? 0));
-  const geometryFactor = Math.max(1, triangleCount / 131072);
-  const includeAccelerationBuild = options.includeAccelerationBuild === true;
-  const accelerationFactor = includeAccelerationBuild ? estimateAccelerationBuildWaitFactor(config) : 1;
-  const estimatedWindowMs = Math.round(
-    (GPU_SUBMITTED_WORK_TIMEOUT_MS + estimatedPasses * 5) * geometryFactor * accelerationFactor
-  );
-  const timeoutMs = Math.min(
-    GPU_MAX_SUBMITTED_WORK_TIMEOUT_MS,
-    Math.max(GPU_SUBMITTED_WORK_TIMEOUT_MS, estimatedWindowMs)
-  );
-  const maxWaitMultiplier = includeAccelerationBuild ? 3 : 2;
-  const maxWaitMs = Math.min(
-    GPU_MAX_SUBMITTED_WORK_DEADLINE_MS,
-    Math.max(timeoutMs, estimatedWindowMs * maxWaitMultiplier)
+function createAtlasTextureResource(device, constants, atlas, label) {
+  const upload = createRgba8TextureUpload(atlas);
+  const texture = device.createTexture({
+    label,
+    size: { width: upload.width, height: upload.height },
+    format: "rgba8unorm",
+    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
+  });
+  device.queue.writeTexture(
+    { texture },
+    upload.bytes,
+    { bytesPerRow: upload.bytesPerRow, rowsPerImage: upload.height },
+    { width: upload.width, height: upload.height, depthOrArrayLayers: 1 }
   );
   return Object.freeze({
-    timeoutMs,
-    maxWaitMs
+    texture,
+    view: texture.createView(),
+    ownsTexture: true
   });
 }
 
+// src/wavefront-instance-shader.js
+var WAVEFRONT_INSTANCE_SHADER_WGSL = `
+struct MeshInstance {
+  world: mat4x4<f32>,
+  inverse: mat4x4<f32>,
+  objectId: u32,
+  root: u32,
+  handedness: f32,
+  _pad: u32,
+};
+@group(0) @binding(47) var meshInstances: texture_2d<u32>;
+fn read_mesh_instance(index: u32) -> MeshInstance {
+  let y = i32(index);
+  let metadata = textureLoad(meshInstances, vec2<i32>(8, y), 0);
+  return MeshInstance(
+    mat4x4<f32>(bitcast<vec4<f32>>(textureLoad(meshInstances, vec2<i32>(0, y), 0)),
+      bitcast<vec4<f32>>(textureLoad(meshInstances, vec2<i32>(1, y), 0)),
+      bitcast<vec4<f32>>(textureLoad(meshInstances, vec2<i32>(2, y), 0)),
+      bitcast<vec4<f32>>(textureLoad(meshInstances, vec2<i32>(3, y), 0))),
+    mat4x4<f32>(bitcast<vec4<f32>>(textureLoad(meshInstances, vec2<i32>(4, y), 0)),
+      bitcast<vec4<f32>>(textureLoad(meshInstances, vec2<i32>(5, y), 0)),
+      bitcast<vec4<f32>>(textureLoad(meshInstances, vec2<i32>(6, y), 0)),
+      bitcast<vec4<f32>>(textureLoad(meshInstances, vec2<i32>(7, y), 0))),
+    metadata.x, metadata.y, bitcast<f32>(metadata.z), 0u);
+}
+
+fn instance_normal(instance: MeshInstance, normal: vec3<f32>) -> vec3<f32> {
+  let normalMatrix = transpose(mat3x3<f32>(instance.inverse[0].xyz, instance.inverse[1].xyz, instance.inverse[2].xyz));
+  return safe_normalize(normalMatrix * normal, vec3<f32>(0.0, 1.0, 0.0));
+}
+
+fn triangle_for_candidate(candidate: Candidate) -> TriangleRecord {
+  var triangle = triangles[candidate.triangleIndex];
+  let instance = read_mesh_instance(candidate.instanceIndex);
+  triangle.v0 = instance.world * vec4<f32>(triangle.v0.xyz, 1.0);
+  triangle.v1 = instance.world * vec4<f32>(triangle.v1.xyz, 1.0);
+  triangle.v2 = instance.world * vec4<f32>(triangle.v2.xyz, 1.0);
+  triangle.meshId = instance.objectId;
+  return triangle;
+}
+
+fn intersect_bvh(ray: RayRecord, initialNearest: f32) -> Candidate {
+  var nearest = initialNearest;
+  var best = no_candidate();
+  var stack = array<u32, 64>();
+  var stackSize = 1u;
+  stack[0] = 0u;
+  loop {
+    if (stackSize == 0u) { break; }
+    stackSize -= 1u;
+    let node = bvhNodes[stack[stackSize]];
+    if (!intersect_bounds(ray, node.boundsMin.xyz, node.boundsMax.xyz, nearest)) { continue; }
+    if (node.triangleCount == 0u) {
+      stack[stackSize] = node.childOrFirst;
+      stack[stackSize + 1u] = node.rightChild;
+      stackSize += 2u;
+    } else {
+      let instanceIndex = node.childOrFirst;
+      let instance = read_mesh_instance(instanceIndex);
+      var localRay = ray;
+      localRay.origin = instance.inverse * vec4<f32>(ray.origin.xyz, 1.0);
+      // Keep this direction unnormalized so t remains the world-space ray parameter.
+      localRay.direction = instance.inverse * vec4<f32>(ray.direction.xyz, 0.0);
+      var candidate = intersect_geometry_bvh(localRay, nearest, instance.root);
+      if (candidate.hit == 1u && candidate.distance < nearest) {
+        candidate.geometricNormal = instance_normal(instance, candidate.geometricNormal);
+        candidate.shadingNormal = repair_shading_normal(candidate.geometricNormal,
+          instance_normal(instance, candidate.shadingNormal));
+        if (instance.handedness < 0.0) { candidate.frontFace = 1u - candidate.frontFace; }
+        candidate.instanceIndex = instanceIndex;
+        nearest = candidate.distance;
+        best = candidate;
+      }
+    }
+  }
+  return best;
+}
+`;
+var WAVEFRONT_UNINSTANCED_SHADER_WGSL = `
+fn triangle_for_candidate(candidate: Candidate) -> TriangleRecord {
+  return triangles[candidate.triangleIndex];
+}
+fn intersect_bvh(ray: RayRecord, initialNearest: f32) -> Candidate {
+  return intersect_geometry_bvh(ray, initialNearest, 0u);
+}
+`;
+
 // src/wavefront-shader-bvh.js
 var WAVEFRONT_SHADER_BVH_WGSL = `
 fn default_mesh_range() -> MeshRange {
@@ -5370,6 +5711,7 @@ fn no_candidate() -> Candidate {
     1u,
     0xffffffffu,
     0xffffffffu,
+    0xffffffffu,
     0u,
     0u
   );
@@ -5396,6 +5738,7 @@ fn surface_candidate(
     uv,
     frontFace,
     triangleIndex,
+    0xffffffffu,
     primitiveId,
     materialRefId,
     mediumRefId
@@ -5457,7 +5800,7 @@ fn intersect_triangle(ray: RayRecord, triangle: TriangleRecord, triangleIndex: u
   );
 }
 
-fn intersect_bvh(ray: RayRecord, initialNearest: f32) -> Candidate {
+fn intersect_geometry_bvh(ray: RayRecord, initialNearest: f32, root: u32) -> Candidate {
   var nearest = initialNearest;
   var best = no_candidate();
   if (config.bvhNodeCount == 0u || config.triangleCount == 0u) {
@@ -5466,7 +5809,7 @@ fn intersect_bvh(ray: RayRecord, initialNearest: f32) -> Candidate {
 
   var stack = array<u32, 64>();
   var stackSize = 1u;
-  stack[0] = 0u;
+  stack[0] = root;
 
   loop {
     if (stackSize == 0u) {
@@ -5757,7 +6100,7 @@ fn intersectActiveQueue(@builtin(global_invocation_id) globalId: vec3<u32>) {
   if (meshCandidate.hit == 1u && meshCandidate.distance < nearest) {
     nearest = meshCandidate.distance;
     candidate = meshCandidate;
-    hitTriangle = triangles[meshCandidate.triangleIndex];
+    hitTriangle = triangle_for_candidate(meshCandidate);
   }
 
   if (candidate.hit == 0u) {
@@ -6911,6 +7254,7 @@ struct Candidate {
   uv: vec2<f32>,
   frontFace: u32,
   triangleIndex: u32,
+  instanceIndex: u32,
   primitiveId: u32,
   materialRefId: u32,
   mediumRefId: u32,
@@ -8508,6 +8852,7 @@ var WAVEFRONT_COMPUTE_WGSL = [
   WAVEFRONT_SHADER_MATERIALS_WGSL,
   WAVEFRONT_SHADER_LIGHTING_WGSL,
   WAVEFRONT_SHADER_BVH_WGSL,
+  WAVEFRONT_UNINSTANCED_SHADER_WGSL,
   WAVEFRONT_SHADER_KERNELS_WGSL
 ].join("\n");
 function createWavefrontPathTracingComputeShaderSource(options = {}) {
@@ -8519,7 +8864,7 @@ function createWavefrontPathTracingComputeShaderSource(options = {}) {
   if (workgroupSize !== WAVEFRONT_COMPUTE_WORKGROUP_SIZE) {
     throw new Error(`wavefront mesh compute currently requires workgroupSize=${WAVEFRONT_COMPUTE_WORKGROUP_SIZE}`);
   }
-  return WAVEFRONT_COMPUTE_WGSL;
+  return options.instanced === true ? WAVEFRONT_COMPUTE_WGSL.replace(WAVEFRONT_UNINSTANCED_SHADER_WGSL, WAVEFRONT_INSTANCE_SHADER_WGSL) : WAVEFRONT_COMPUTE_WGSL;
 }
 
 // src/wavefront-progressive-shader.js
@@ -9523,7 +9868,7 @@ function chooseSplitAxis(triangles) {
   }
   return extent[1] >= extent[2] ? 1 : 2;
 }
-function buildBvh(triangles, maxLeafTriangles = 4) {
+function buildWavefrontBoundsBvh(triangles, maxLeafTriangles = 4) {
   if (triangles.length === 0) {
     return Object.freeze({ nodes: Object.freeze([]), triangles: Object.freeze([]) });
   }
@@ -9575,7 +9920,7 @@ function createWavefrontMeshAcceleration(meshes = [], gpuMaterialSource = null)
   const source = Array.isArray(meshes) ? meshes : [meshes];
   const resolvedMaterialSource = gpuMaterialSource ?? createWavefrontGpuMaterialSource(source);
   const triangles = createMeshTriangleRecords(source, resolvedMaterialSource);
-  return buildBvh(triangles);
+  return buildWavefrontBoundsBvh(triangles);
 }
 function estimateMeshSourceShape(meshes) {
   const source = Array.isArray(meshes) ? meshes : [];
@@ -10393,6 +10738,145 @@ function dispatchWavefrontGpuAccelerationBuild({
   return true;
 }
 
+// src/wavefront-instances.js
+var WAVEFRONT_INSTANCE_BYTES = 144;
+var freeze = Object.freeze;
+var uint = (value) => Number.isInteger(value) && value >= 0 && value < 4294967295;
+function affineTransform(value) {
+  if (!Array.isArray(value) && !ArrayBuffer.isView(value) || value.length !== 16 || !Array.from(value).every((n) => Number.isFinite(n) && Math.abs(n) <= 1e12) || value[3] !== 0 || value[7] !== 0 || value[11] !== 0 || value[15] !== 1) {
+    throw new Error("Instance transform must be a finite affine column-major matrix.");
+  }
+  const m = Array.from(value, Math.fround);
+  const [a, b, c, , d, e, f, , g, h, i] = m;
+  const determinant = a * (e * i - f * h) - d * (b * i - c * h) + g * (b * f - c * e);
+  if (!Number.isFinite(determinant) || Math.abs(determinant) < 1e-12) {
+    throw new Error("Instance transform must be invertible.");
+  }
+  const inv = [
+    (e * i - f * h) / determinant,
+    (c * h - b * i) / determinant,
+    (b * f - c * e) / determinant,
+    0,
+    (f * g - d * i) / determinant,
+    (a * i - c * g) / determinant,
+    (c * d - a * f) / determinant,
+    0,
+    (d * h - e * g) / determinant,
+    (b * g - a * h) / determinant,
+    (a * e - b * d) / determinant,
+    0,
+    0,
+    0,
+    0,
+    1
+  ];
+  for (let r = 0; r < 3; r++) inv[12 + r] = -(inv[r] * m[12] + inv[4 + r] * m[13] + inv[8 + r] * m[14]);
+  if (!inv.every((n) => Number.isFinite(n) && Math.abs(n) <= 1e12)) throw new Error("Instance inverse transform is out of range.");
+  return { transform: freeze(m), inverse: freeze(inv.map((n) => n === 0 ? 0 : n)), handedness: Math.sign(determinant) };
+}
+function transformInstancePoint(m, p) {
+  return [0, 1, 2].map((r) => m[r] * p[0] + m[4 + r] * p[1] + m[8 + r] * p[2] + m[12 + r]);
+}
+function meshBounds(mesh) {
+  const localMin = [Infinity, Infinity, Infinity], localMax = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < mesh.positions.length; i += 3) for (let a = 0; a < 3; a++) {
+    localMin[a] = Math.min(localMin[a], Math.fround(mesh.positions[i + a]));
+    localMax[a] = Math.max(localMax[a], Math.fround(mesh.positions[i + a]));
+  }
+  return { min: localMin, max: localMax };
+}
+function boundsOf(local, transform) {
+  const localMin = local.min, localMax = local.max;
+  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+  for (let corner = 0; corner < 8; corner++) {
+    const p = transformInstancePoint(transform, [0, 1, 2].map((a) => corner & 1 << a ? localMax[a] : localMin[a]));
+    for (let a = 0; a < 3; a++) {
+      min[a] = Math.min(min[a], p[a]);
+      max[a] = Math.max(max[a], p[a]);
+    }
+  }
+  if (![...min, ...max].every(Number.isFinite)) throw new Error("Instance mesh has invalid bounds.");
+  return freeze({ min: freeze(min), max: freeze(max) });
+}
+function prepareWavefrontInstances(meshes, instances) {
+  if (!Array.isArray(instances) || instances.length === 0) throw new Error("Instances must be a nonempty array.");
+  const byId = /* @__PURE__ */ new Map(), localBounds = /* @__PURE__ */ new Map();
+  for (const mesh of meshes) {
+    if (!uint(mesh.id) || byId.has(mesh.id)) throw new Error("Instanced mesh IDs must be unique unsigned integers.");
+    if (mesh.materialKind === MATERIAL_EMISSIVE || emissionPower(mesh.emission ?? [0, 0, 0, 1]) > 1e-4) {
+      throw new Error("Instanced emissive meshes require per-instance light sampling, which is not supported yet.");
+    }
+    byId.set(mesh.id, mesh);
+    localBounds.set(mesh.id, meshBounds(mesh));
+  }
+  const ids = /* @__PURE__ */ new Set(), used = /* @__PURE__ */ new Set();
+  const records = instances.map((instance) => {
+    if (!instance || !uint(instance.id) || ids.has(instance.id)) throw new Error("Instance IDs must be unique unsigned integers.");
+    const mesh = byId.get(instance.meshId);
+    if (!mesh) throw new Error("Instance references an unknown mesh.");
+    ids.add(instance.id);
+    used.add(mesh.id);
+    const affine = affineTransform(instance.transform);
+    const bounds = boundsOf(localBounds.get(mesh.id), affine.transform);
+    return freeze({
+      ...affine,
+      id: instance.id,
+      meshId: mesh.id,
+      bounds,
+      centroid: freeze(bounds.min.map((v, a) => (v + bounds.max[a]) / 2))
+    });
+  });
+  if (used.size !== meshes.length) throw new Error("Every instanced mesh must have at least one instance.");
+  return freeze({ records: freeze(records), geometryCount: meshes.length });
+}
+function buildWavefrontInstances(meshes, plan, materialSource) {
+  const tlas = buildWavefrontBoundsBvh(plan.records, 1);
+  const nodes = tlas.nodes.map((node) => {
+    const pad = node.bounds.min.map((v, a) => Math.max(1, Math.abs(v), Math.abs(node.bounds.max[a])) * 1e-6);
+    return freeze({ ...node, bounds: freeze({
+      min: freeze(node.bounds.min.map((v, a) => v - pad[a])),
+      max: freeze(node.bounds.max.map((v, a) => v + pad[a]))
+    }) });
+  }), triangles = [], roots = /* @__PURE__ */ new Map();
+  for (const [meshIndex, mesh] of meshes.entries()) {
+    const blas = createWavefrontMeshAcceleration([mesh], materialSource);
+    const nodeOffset = nodes.length, triangleOffset = triangles.length;
+    roots.set(mesh.id, nodeOffset);
+    for (const node of blas.nodes) nodes.push(freeze({
+      ...node,
+      firstTriangle: node.firstTriangle + (node.triangleCount > 0 ? triangleOffset : nodeOffset),
+      leftChild: node.leftChild + nodeOffset,
+      rightChild: node.rightChild + nodeOffset
+    }));
+    for (const triangle of blas.triangles) triangles.push(freeze({
+      ...triangle,
+      triangleId: triangle.triangleId + triangleOffset,
+      materialSlot: meshIndex
+    }));
+  }
+  const records = tlas.triangles.map((record) => freeze({ ...record, root: roots.get(record.meshId) }));
+  const buffer = new ArrayBuffer(records.length * WAVEFRONT_INSTANCE_BYTES);
+  const floats = new Float32Array(buffer), uints = new Uint32Array(buffer);
+  records.forEach((record, index) => {
+    const offset = index * 36;
+    floats.set(record.transform, offset);
+    floats.set(record.inverse, offset + 16);
+    uints[offset + 32] = record.id;
+    uints[offset + 33] = record.root;
+    floats[offset + 34] = record.handedness;
+  });
+  return freeze({
+    records: freeze(records),
+    buffer,
+    instanceCount: records.length,
+    geometryCount: meshes.length,
+    instanceBytes: buffer.byteLength,
+    tlasNodeCount: tlas.nodes.length,
+    blasNodeCount: nodes.length - tlas.nodes.length,
+    acceleration: freeze({ nodes: freeze(nodes), triangles: freeze(triangles) })
+  });
+}
+
 // src/wavefront-config.js
 var WEBGPU_DEFAULT_MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 256;
 function allocatedRecordBytes(count, recordBytes) {
@@ -10666,6 +11150,7 @@ function estimateWavefrontPathTracingMemory(options = {}) {
   const progressiveBytes = options.progressive === true ? width * height * 16 + 16 : 0;
   const pathVertexBytes = tilePixelCapacity * (maxDepth + 1) * PATH_VERTEX_RECORD_BYTES;
   const sceneObjectBytes = sceneObjectCapacity * SCENE_OBJECT_RECORD_BYTES;
+  const instanceBytes = readNonNegativeInteger2("instanceBytes", options.instanceBytes, 0);
   const triangleBytes = allocatedRecordBytes(triangleCapacity, TRIANGLE_RECORD_BYTES);
   const materialTableBytes = 0;
   const bvhNodeBytes = bvhNodeCapacity * BVH_NODE_RECORD_BYTES;
@@ -10721,6 +11206,7 @@ function estimateWavefrontPathTracingMemory(options = {}) {
     pathVertexBytes,
     sceneObjectBytes,
     triangleBytes,
+    instanceBytes,
     materialTableBytes,
     bvhNodeBytes,
     bvhCombinedBytes,
@@ -10750,6 +11236,7 @@ function estimateWavefrontPathTracingMemoryForConfig(config, limits = {}) {
     maxDepth: config.maxDepth,
     sceneObjectCapacity: config.sceneObjectCapacity,
     triangleCapacity: config.triangleCapacity,
+    instanceBytes: config.instancing?.instanceBytes ?? 0,
     bvhNodeCapacity: config.bvhNodeCapacity,
     bvhLeafSortCapacity: config.bvhLeafSortCapacity,
     emissiveTriangleCapacity: config.emissiveTriangleCapacity,
@@ -10768,6 +11255,7 @@ function estimateWavefrontPathTracingMemoryForConfig(config, limits = {}) {
 function createWavefrontPathTracingComputeConfig(options = {}) {
   assertAnalyticDisplayQualityPolicy(options);
   const accelerationBuildMode = resolveAccelerationBuildMode(options);
+  if (options.instances !== void 0 && accelerationBuildMode === "gpu") throw new Error("Instance BLAS construction currently requires cpu-upload acceleration.");
   const canvas = options.canvas;
   const width = readPositiveInteger2("width", options.width, getCanvasDimension(canvas, "width", DEFAULT_WIDTH));
   const height = readPositiveInteger2("height", options.height, getCanvasDimension(canvas, "height", DEFAULT_HEIGHT));
@@ -10798,9 +11286,16 @@ function createWavefrontPathTracingComputeConfig(options = {}) {
   );
   const meshes = normalizeMeshes(options);
   const meshSourceShape = estimateMeshSourceShape(meshes);
+  if (options.memoryBudgetBytes !== void 0) {
+    if (!Number.isSafeInteger(options.memoryBudgetBytes) || options.memoryBudgetBytes <= 0) throw new Error("GPU memory budget must be a positive safe integer.");
+    const geometryMinimumBytes = meshSourceShape.triangleCount * TRIANGLE_RECORD_BYTES + (options.instances?.length ?? 0) * 144;
+    if (!Number.isSafeInteger(geometryMinimumBytes) || geometryMinimumBytes > options.memoryBudgetBytes) throw new Error("Unique geometry exceeds the GPU memory budget before acceleration construction.");
+  }
+  const instancePlan = options.instances === void 0 ? null : prepareWavefrontInstances(meshes, options.instances);
   const gpuMaterialSource = meshes.length > 0 ? createWavefrontGpuMaterialSource(meshes) : createWavefrontGpuMaterialSource([]);
   const gpuMeshSource = meshes.length > 0 ? createWavefrontGpuMeshSource(meshes, gpuMaterialSource) : createWavefrontGpuMeshSource([]);
-  const meshAcceleration = accelerationBuildMode === "cpu-upload" ? createWavefrontMeshAcceleration(meshes, gpuMaterialSource) : Object.freeze({ nodes: Object.freeze([]), triangles: Object.freeze([]) });
+  const instancing = instancePlan ? buildWavefrontInstances(meshes, instancePlan, gpuMaterialSource) : null;
+  const meshAcceleration = instancing?.acceleration ?? (accelerationBuildMode === "cpu-upload" ? createWavefrontMeshAcceleration(meshes, gpuMaterialSource) : Object.freeze({ nodes: Object.freeze([]), triangles: Object.freeze([]) }));
   const emissiveTriangleIndices = createWavefrontEmissiveTriangleIndexSource(
     meshes,
     options.emissiveTriangleCapacity
@@ -10878,6 +11373,7 @@ function createWavefrontPathTracingComputeConfig(options = {}) {
     gpuAccelerationBuildRequired: accelerationBuildMode === "gpu" && triangleCount > 0,
     gpuMeshSource,
     gpuMaterialSource,
+    instancing,
     meshAcceleration,
     emissiveTriangleIndices,
     emissiveTriangleCount: emissiveTriangleIndices.count,
@@ -10916,6 +11412,7 @@ function createWavefrontPathTracingComputeConfig(options = {}) {
       tilePixelCapacity,
       maxDepth,
       sceneObjectCapacity,
+      instanceBytes: instancing?.instanceBytes ?? 0,
       triangleCapacity,
       bvhNodeCapacity,
       bvhLeafSortCapacity,
@@ -10949,6 +11446,7 @@ function createWavefrontTraceBindGroup({
   counterBuffer,
   outputView,
   triangleBuffer,
+  instanceView,
   bvhNodeBuffer,
   radianceView,
   environmentPortalBuffer,
@@ -11006,7 +11504,8 @@ function createWavefrontTraceBindGroup({
       { binding: 41, resource: extensionAtlasResources.specularColor.view },
       { binding: 42, resource: extensionAtlasResources.iridescence.view },
       { binding: 43, resource: extensionAtlasResources.iridescenceThickness.view },
-      { binding: 44, resource: extensionAtlasResources.anisotropy.view }
+      { binding: 44, resource: extensionAtlasResources.anisotropy.view },
+      ...instanceView ? [{ binding: 47, resource: instanceView }] : []
     ]
   });
 }
@@ -11104,115 +11603,39 @@ function createWavefrontDenoiseBindGroups({
       inputView: radianceView,
       targetView: denoiseScratchView,
       label: "plasius.wavefront.bind.denoise.radianceToScratch"
-    }),
-    resolve: createWavefrontDenoiseResolveBindGroup({
-      device,
-      denoiseResolveBindGroupLayout,
-      configBuffer,
-      inputView: denoiseScratchView,
-      targetView: outputView,
-      label: "plasius.wavefront.bind.denoise.scratchToOutput"
-    }),
-    directResolve: createWavefrontDenoiseResolveBindGroup({
-      device,
-      denoiseResolveBindGroupLayout,
-      configBuffer,
-      inputView: radianceView,
-      targetView: outputView,
-      label: "plasius.wavefront.bind.denoise.radianceToOutput"
-    })
-  });
-}
-function createWavefrontPresentBindGroup({
-  device,
-  presentBindGroupLayout,
-  outputView,
-  sampler
-}) {
-  return device.createBindGroup({
-    label: "plasius.wavefront.presentBindGroup",
-    layout: presentBindGroupLayout,
-    entries: [
-      { binding: 0, resource: outputView },
-      { binding: 1, resource: sampler }
-    ]
-  });
-}
-
-// src/wavefront-gpu-synchronization.js
-async function waitForSubmittedGpuWork(device, options = {}) {
-  if (typeof device.queue.onSubmittedWorkDone !== "function") {
-    return true;
-  }
-  const timeoutMs = Math.max(
-    1,
-    Number.isFinite(options.timeoutMs) ? Number(options.timeoutMs) : GPU_SUBMITTED_WORK_TIMEOUT_MS
-  );
-  const maxWaitMs = Math.max(
-    timeoutMs,
-    Number.isFinite(options.maxWaitMs) ? Number(options.maxWaitMs) : timeoutMs
-  );
-  const allowTimeout = options.allowTimeout !== false;
-  const completionPromise = device.queue.onSubmittedWorkDone().then(
-    () => ({ status: "done" }),
-    (error) => {
-      throw error;
-    }
-  );
-  const lossPromise = typeof device.lost?.then === "function" ? device.lost.then((info) => {
-    throw new Error(
-      `WebGPU device lost while waiting for submitted work (${info?.reason ?? "unknown"}).`
-    );
-  }) : null;
-  const startedAtMs = nowMs3();
-  while (true) {
-    const elapsedMs = Math.max(0, nowMs3() - startedAtMs);
-    const remainingMs = Math.max(0, maxWaitMs - elapsedMs);
-    if (remainingMs <= 0) {
-      if (!allowTimeout) {
-        throw new Error(`Timed out after ${Math.round(maxWaitMs)} ms waiting for submitted GPU work.`);
-      }
-      console.warn(
-        `[plasius.wavefront] Submitted GPU work did not report completion within ${Math.round(maxWaitMs)} ms; continuing.`
-      );
-      return false;
-    }
-    const waitWindowMs = Math.max(1, Math.min(timeoutMs, remainingMs));
-    let timeoutHandle = null;
-    let resolveTimeoutPromise = null;
-    let timeoutSettled = false;
-    const settleTimeoutPromise = (value) => {
-      if (timeoutSettled) {
-        return;
-      }
-      timeoutSettled = true;
-      resolveTimeoutPromise?.(value);
-    };
-    const timeoutPromise = new Promise((resolve) => {
-      resolveTimeoutPromise = resolve;
-      timeoutHandle = setTimeout(
-        () => settleTimeoutPromise({ status: "timeout" }),
-        waitWindowMs
-      );
-    });
-    let result;
-    try {
-      result = await Promise.race(
-        [completionPromise, timeoutPromise, lossPromise].filter(Boolean)
-      );
-    } finally {
-      if (timeoutHandle !== null) {
-        clearTimeout(timeoutHandle);
-        settleTimeoutPromise({ status: "cancelled" });
-      }
-    }
-    if (result?.status === "done") {
-      return true;
-    }
-    if (result?.status !== "timeout") {
-      return true;
-    }
-  }
+    }),
+    resolve: createWavefrontDenoiseResolveBindGroup({
+      device,
+      denoiseResolveBindGroupLayout,
+      configBuffer,
+      inputView: denoiseScratchView,
+      targetView: outputView,
+      label: "plasius.wavefront.bind.denoise.scratchToOutput"
+    }),
+    directResolve: createWavefrontDenoiseResolveBindGroup({
+      device,
+      denoiseResolveBindGroupLayout,
+      configBuffer,
+      inputView: radianceView,
+      targetView: outputView,
+      label: "plasius.wavefront.bind.denoise.radianceToOutput"
+    })
+  });
+}
+function createWavefrontPresentBindGroup({
+  device,
+  presentBindGroupLayout,
+  outputView,
+  sampler
+}) {
+  return device.createBindGroup({
+    label: "plasius.wavefront.presentBindGroup",
+    layout: presentBindGroupLayout,
+    entries: [
+      { binding: 0, resource: outputView },
+      { binding: 1, resource: sampler }
+    ]
+  });
 }
 
 // src/wavefront-frame-telemetry.js
@@ -12039,7 +12462,7 @@ function dispatchWavefrontFrameAwaitingGpu({
 }
 
 // src/wavefront-pipelines.js
-function createWavefrontBindGroupLayouts(device, constants) {
+function createWavefrontBindGroupLayouts(device, constants, instanced = false) {
   const trace = device.createBindGroupLayout({
     label: "plasius.wavefront.traceBindGroupLayout",
     entries: [
@@ -12091,7 +12514,8 @@ function createWavefrontBindGroupLayouts(device, constants) {
       { binding: 41, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
       { binding: 42, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
       { binding: 43, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
-      { binding: 44, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } }
+      { binding: 44, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      ...instanced ? [{ binding: 47, visibility: constants.shader.COMPUTE, texture: { sampleType: "uint" } }] : []
     ]
   });
   const acceleration = device.createBindGroupLayout({
@@ -12286,12 +12710,12 @@ async function createWavefrontPresentPipeline(device, presentBindGroupLayout, fo
     primitive: { topology: "triangle-list" }
   });
 }
-async function createWavefrontPipelineResources({ device, constants, format }) {
-  const bindGroupLayouts = createWavefrontBindGroupLayouts(device, constants);
+async function createWavefrontPipelineResources({ device, constants, format, instanced = false }) {
+  const bindGroupLayouts = createWavefrontBindGroupLayouts(device, constants, instanced);
   const pipelineLayouts = createWavefrontPipelineLayouts(device, bindGroupLayouts);
   const computeShader = device.createShaderModule({
     label: "plasius.wavefront.computeShader",
-    code: WAVEFRONT_COMPUTE_WGSL
+    code: createWavefrontPathTracingComputeShaderSource({ instanced })
   });
   await assertShaderModuleCompiles(computeShader, "plasius.wavefront.computeShader");
   return Object.freeze({
@@ -12724,890 +13148,911 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
   if (!adapter) {
     throw new Error("Unable to acquire a WebGPU adapter for wavefront path tracing.");
   }
-  const device = await adapter.requestDevice(
+  const rawDevice = await adapter.requestDevice(
     createWavefrontDeviceDescriptor(adapter, options, initialConfig.memory)
   );
-  const gpuAdapterParallelism = createGpuAdapterParallelismDiagnostics(adapter, device);
-  const context = canvas.getContext("webgpu");
-  if (!context || typeof context.configure !== "function") {
-    throw new Error("Canvas WebGPU context does not support configure().");
-  }
-  const format = options.format ?? (typeof navigatorRef.gpu.getPreferredCanvasFormat === "function" ? navigatorRef.gpu.getPreferredCanvasFormat() : "bgra8unorm");
-  let config = initialConfig;
-  const safeTileSize = clampTileSizeForDevice(config, device);
-  if (safeTileSize !== config.tileSize) {
-    config = createWavefrontPathTracingComputeConfig({
-      ...options,
-      canvas,
-      width: config.width,
-      height: config.height,
-      tileSize: safeTileSize,
-      tilePixelCapacity: Math.min(
-        config.tilePixelCapacity,
-        safeTileSize * safeTileSize
-      )
-    });
-  }
-  config = Object.freeze({
-    ...config,
-    memory: estimateWavefrontPathTracingMemoryForConfig(config, device.limits)
-  });
-  canvas.width = config.width;
-  canvas.height = config.height;
-  context.configure({
-    device,
-    format,
-    alphaMode: options.alpha === true ? "premultiplied" : "opaque"
-  });
-  const bufferUsage = constants.buffer.STORAGE | constants.buffer.COPY_DST;
-  const memory = config.memory;
-  const activeQueue = createBuffer(device, bufferUsage, memory.queueBytes, "plasius.wavefront.activeQueue");
-  const nextQueue = createBuffer(device, bufferUsage, memory.queueBytes, "plasius.wavefront.nextQueue");
-  const hitBuffer = createBuffer(device, bufferUsage, memory.hitBytes, "plasius.wavefront.hitBuffer");
-  const accumulationBuffer = createBuffer(
-    device,
-    bufferUsage,
-    memory.accumulationBytes,
-    "plasius.wavefront.accumulation"
-  );
-  const pathVertexBuffer = createBuffer(
-    device,
-    bufferUsage,
-    memory.pathVertexBytes,
-    "plasius.wavefront.pathVertices"
-  );
-  const sceneObjectBuffer = createBuffer(
-    device,
-    constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    memory.sceneObjectBytes,
-    "plasius.wavefront.sceneObjects"
-  );
-  const triangleBuffer = createBuffer(
-    device,
-    constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    memory.triangleBytes,
-    "plasius.wavefront.triangles"
-  );
-  const bvhNodeBuffer = createBuffer(
-    device,
-    constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    memory.bvhCombinedBytes,
-    "plasius.wavefront.bvhNodes"
-  );
-  const meshVertexBuffer = createBuffer(
-    device,
-    constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    memory.meshVertexBytes,
-    "plasius.wavefront.meshVertices"
-  );
-  const meshIndexBuffer = createBuffer(
-    device,
-    constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    memory.meshIndexBytes,
-    "plasius.wavefront.meshIndices"
-  );
-  const meshRangeBuffer = createBuffer(
-    device,
-    constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    memory.meshRangeBytes,
-    "plasius.wavefront.meshRanges"
-  );
-  const environmentPortalBuffer = createBuffer(
-    device,
-    constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    memory.environmentPortalBytes,
-    "plasius.wavefront.environmentPortals"
-  );
-  const bvhLeafRefBuffer = createBuffer(
-    device,
-    constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    memory.bvhLeafReferenceBytes,
-    "plasius.wavefront.bvhLeafRefs"
-  );
-  const tiles = createTiles(config.width, config.height, config.tileSize);
-  const configBufferStride = memory.configBufferStride;
-  const outputConfigSlotCount = config.deferredPathResolve ? 0 : tiles.length;
-  const frameConfigSlotCount = Math.max(
-    1,
-    tiles.length * config.samplesPerPixel + outputConfigSlotCount + (config.denoise || config.progressive ? 1 : 0)
-  );
-  const configBuffer = createBuffer(
-    device,
-    constants.buffer.UNIFORM | constants.buffer.COPY_DST,
-    memory.frameConfigBytes,
-    "plasius.wavefront.frameConfig"
-  );
-  const bvhBuildConfigBuffer = createBuffer(
-    device,
-    constants.buffer.UNIFORM | constants.buffer.COPY_DST,
-    memory.bvhBuildConfigBytes,
-    "plasius.wavefront.bvhBuildConfig"
-  );
-  const counterBuffer = createBuffer(
-    device,
-    constants.buffer.STORAGE | constants.buffer.COPY_DST | constants.buffer.COPY_SRC,
-    memory.counterBytes,
-    "plasius.wavefront.counters"
-  );
-  const activeDispatchBuffer = createBuffer(
-    device,
-    constants.buffer.INDIRECT | constants.buffer.COPY_DST,
-    memory.indirectDispatchBytes,
-    "plasius.wavefront.activeDispatchArgs"
-  );
-  let packedScene = packWavefrontSceneObjects(config.sceneObjects, config.sceneObjectCapacity);
-  device.queue.writeBuffer(sceneObjectBuffer, 0, packedScene.buffer);
-  const packedTriangles = packWavefrontTriangles(
-    config.meshAcceleration.triangles,
-    Math.max(1, config.triangleCapacity)
-  );
-  const packedBvhNodes = packWavefrontBvhNodes(
-    config.meshAcceleration.nodes,
-    Math.max(1, config.bvhNodeCapacity + config.emissiveTriangleCapacity)
-  );
-  const packedBvhNodeUints = new Uint32Array(packedBvhNodes.buffer);
-  const packedBvhNodeFloats = new Float32Array(packedBvhNodes.buffer);
-  const orderedEmissiveTriangleIndices = resolveOrderedEmissiveTriangleIndices(config);
-  const emissiveWeights = orderedEmissiveTriangleIndices.map(
-    (triangleIndex) => emissiveTriangleWeight(config.meshAcceleration.triangles[triangleIndex])
-  );
-  const totalEmissiveWeight = emissiveWeights.reduce((total, weight) => total + weight, 0);
-  let cumulativeEmissiveWeight = 0;
-  orderedEmissiveTriangleIndices.forEach((triangleIndex, index) => {
-    const nodeOffset = (config.bvhNodeCapacity + index) * (BVH_NODE_RECORD_BYTES / 4);
-    cumulativeEmissiveWeight += emissiveWeights[index] ?? 0;
-    packedBvhNodeFloats[nodeOffset] = cumulativeEmissiveWeight;
-    packedBvhNodeFloats[nodeOffset + 1] = emissiveWeights[index] ?? 0;
-    packedBvhNodeFloats[nodeOffset + 2] = totalEmissiveWeight;
-    packedBvhNodeUints[nodeOffset + 8] = triangleIndex;
-  });
-  device.queue.writeBuffer(triangleBuffer, 0, packedTriangles.buffer);
-  device.queue.writeBuffer(bvhNodeBuffer, 0, packedBvhNodes.buffer);
-  device.queue.writeBuffer(meshVertexBuffer, 0, config.gpuMeshSource.vertices.buffer);
-  device.queue.writeBuffer(meshIndexBuffer, 0, config.gpuMeshSource.indices.buffer);
-  device.queue.writeBuffer(meshRangeBuffer, 0, config.gpuMeshSource.meshes.buffer);
-  const packedEnvironmentPortals = packEnvironmentPortals(
-    config.environmentPortals,
-    Math.max(1, config.environmentPortalCapacity)
-  );
-  device.queue.writeBuffer(environmentPortalBuffer, 0, packedEnvironmentPortals.buffer);
-  const radianceTexture = device.createTexture({
-    label: "plasius.wavefront.radiance",
-    size: { width: config.width, height: config.height },
-    format: "rgba16float",
-    usage: constants.texture.STORAGE_BINDING | constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
-  });
-  const radianceView = radianceTexture.createView();
-  const denoiseScratchTexture = device.createTexture({
-    label: "plasius.wavefront.denoiseScratch",
-    size: { width: config.width, height: config.height },
-    format: "rgba16float",
-    usage: constants.texture.STORAGE_BINDING | constants.texture.TEXTURE_BINDING
-  });
-  const denoiseScratchView = denoiseScratchTexture.createView();
-  const outputTexture = device.createTexture({
-    label: "plasius.wavefront.output",
-    size: { width: config.width, height: config.height },
-    format: "rgba8unorm",
-    usage: constants.texture.STORAGE_BINDING | constants.texture.TEXTURE_BINDING | constants.texture.COPY_SRC
-  });
-  const outputView = outputTexture.createView();
-  const sampler = device.createSampler({
-    label: "plasius.wavefront.presentSampler",
-    magFilter: "nearest",
-    minFilter: "nearest"
-  });
-  const environmentMapResource = createEnvironmentMapResource(
-    device,
-    constants,
-    config.environmentMap,
-    config.environmentColor
-  );
-  const environmentSamplingResource = createEnvironmentSamplingTextureResource(
-    device,
-    constants,
-    config.environmentMap,
-    config.environmentColor
-  );
-  let mediumTextureResource = createMediumTextureResource(
-    device,
-    constants,
-    config.mediums
-  );
-  config = Object.freeze({
-    ...config,
-    environmentMap: Object.freeze({
-      ...config.environmentMap,
-      width: environmentMapResource.width,
-      height: environmentMapResource.height,
-      mipLevelCount: environmentMapResource.mipLevelCount,
-      hasImportanceData: environmentSamplingResource.hasImportanceData
-    })
-  });
-  const brdfLutResource = createBrdfLutResource(device, constants);
-  const baseColorAtlasResource = createAtlasTextureResource(
-    device,
-    constants,
-    config.gpuMaterialSource.baseColorAtlas,
-    "plasius.wavefront.materialAtlas.baseColor"
-  );
-  const metallicRoughnessAtlasResource = createAtlasTextureResource(
-    device,
-    constants,
-    config.gpuMaterialSource.metallicRoughnessAtlas,
-    "plasius.wavefront.materialAtlas.metallicRoughness"
-  );
-  const normalAtlasResource = createAtlasTextureResource(
-    device,
-    constants,
-    config.gpuMaterialSource.normalAtlas,
-    "plasius.wavefront.materialAtlas.normal"
-  );
-  const occlusionAtlasResource = createAtlasTextureResource(
-    device,
-    constants,
-    config.gpuMaterialSource.occlusionAtlas,
-    "plasius.wavefront.materialAtlas.occlusion"
-  );
-  const emissiveAtlasResource = createAtlasTextureResource(
-    device,
-    constants,
-    config.gpuMaterialSource.emissiveAtlas,
-    "plasius.wavefront.materialAtlas.emissive"
-  );
-  const extensionAtlasNames = [
-    "clearcoat",
-    "clearcoatRoughness",
-    "clearcoatNormal",
-    "transmission",
-    "thickness",
-    "sheenColor",
-    "sheenRoughness",
-    "specular",
-    "specularColor",
-    "iridescence",
-    "iridescenceThickness",
-    "anisotropy"
-  ];
-  const extensionAtlasResources = Object.freeze(
-    Object.fromEntries(
-      extensionAtlasNames.map((name) => [
-        name,
-        createAtlasTextureResource(
+  const allocationTracker = createGpuAllocationTracker(rawDevice, { budgetBytes: options.memoryBudgetBytes, storageUsage: constants.buffer.STORAGE });
+  const device = allocationTracker.device;
+  let context, finishAllocationScopes;
+  try {
+    let createTraceBindGroups = function() {
+      return createWavefrontTraceBindGroups({
+        device,
+        traceBindGroupLayout,
+        activeQueue,
+        nextQueue,
+        frameConfigBuffer: configBuffer,
+        hitBuffer,
+        accumulationBuffer,
+        sceneObjectBuffer,
+        counterBuffer,
+        outputView,
+        triangleBuffer,
+        instanceView,
+        bvhNodeBuffer,
+        radianceView,
+        environmentPortalBuffer,
+        environmentMapResource,
+        pathVertexBuffer,
+        baseColorAtlasResource,
+        metallicRoughnessAtlasResource,
+        normalAtlasResource,
+        occlusionAtlasResource,
+        emissiveAtlasResource,
+        materialAtlasSampler,
+        brdfLutResource,
+        environmentSamplingResource,
+        mediumTextureResource,
+        extensionAtlasResources
+      });
+    }, ensureFrameTelemetryResources = function() {
+      if (!frameTelemetryResources) {
+        frameTelemetryResources = createWavefrontFrameTelemetryResources({
           device,
           constants,
-          config.gpuMaterialSource.extensionAtlases[name],
-          `plasius.wavefront.materialAtlas.${name}`
-        )
-      ])
-    )
-  );
-  const materialAtlasSampler = device.createSampler({
-    label: "plasius.wavefront.materialAtlasSampler",
-    addressModeU: "clamp-to-edge",
-    addressModeV: "clamp-to-edge",
-    magFilter: "linear",
-    minFilter: "linear"
-  });
-  const {
-    bindGroupLayouts: {
-      trace: traceBindGroupLayout,
-      acceleration: accelerationBindGroupLayout,
-      denoiseRadiance: denoiseRadianceBindGroupLayout,
-      denoiseResolve: denoiseResolveBindGroupLayout,
-      present: presentBindGroupLayout
-    },
-    computePipelines: pipelines,
-    presentPipeline
-  } = await createWavefrontPipelineResources({ device, constants, format });
-  function createTraceBindGroups() {
-    return createWavefrontTraceBindGroups({
-      device,
-      traceBindGroupLayout,
-      activeQueue,
-      nextQueue,
-      frameConfigBuffer: configBuffer,
-      hitBuffer,
-      accumulationBuffer,
-      sceneObjectBuffer,
-      counterBuffer,
-      outputView,
-      triangleBuffer,
-      bvhNodeBuffer,
-      radianceView,
-      environmentPortalBuffer,
-      environmentMapResource,
-      pathVertexBuffer,
-      baseColorAtlasResource,
-      metallicRoughnessAtlasResource,
-      normalAtlasResource,
-      occlusionAtlasResource,
-      emissiveAtlasResource,
-      materialAtlasSampler,
-      brdfLutResource,
-      environmentSamplingResource,
-      mediumTextureResource,
-      extensionAtlasResources
-    });
-  }
-  let bindGroups = createTraceBindGroups();
-  const bvhBuildBindGroup = createWavefrontBvhBuildBindGroup({
-    device,
-    accelerationBindGroupLayout,
-    bvhBuildConfigBuffer,
-    triangleBuffer,
-    bvhNodeBuffer,
-    meshVertexBuffer,
-    meshIndexBuffer,
-    meshRangeBuffer,
-    bvhLeafRefBuffer
-  });
-  const {
-    radiance: denoiseRadianceBindGroup,
-    resolve: denoiseResolveBindGroup,
-    directResolve: denoiseDirectResolveBindGroup
-  } = createWavefrontDenoiseBindGroups({
-    device,
-    denoiseRadianceBindGroupLayout,
-    denoiseResolveBindGroupLayout,
-    configBuffer,
-    radianceView,
-    denoiseScratchView,
-    outputView
-  });
-  const presentBindGroup = createWavefrontPresentBindGroup({
-    device,
-    presentBindGroupLayout,
-    outputView,
-    sampler
-  });
-  const progressive = await createWavefrontProgressiveResources({ device, constants, config, configBuffer, radianceTexture, radianceView, outputView });
-  let activeFrameTelemetry = null;
-  let frameTelemetryResources = null;
-  const frameEncoder = createWavefrontFrameEncoder({
-    getConfig: () => config,
-    progressive,
-    getBindGroups: () => bindGroups,
-    pipelines,
-    counterBuffer,
-    activeDispatchBuffer,
-    denoiseRadianceBindGroup,
-    denoiseResolveBindGroup,
-    denoiseDirectResolveBindGroup,
-    presentPipeline,
-    presentBindGroup,
-    context,
-    getFrameTelemetry: () => activeFrameTelemetry
-  });
-  let frame = 0;
-  let accelerationBuilt = !config.gpuAccelerationBuildRequired;
-  let accelerationBuildCount = 0;
-  let activeCameraOptions = options.camera ?? DEFAULT_CAMERA2;
-  let lastCompletedFrameTimeMs = null;
-  let lastCompletedSamplesPerPixel = Math.max(1, config.samplesPerPixel);
-  let lastGpuParallelism = createGpuParallelismDiagnostics(
-    gpuAdapterParallelism,
-    createGpuParallelismCounters()
-  );
-  const waitForSubmittedGpuWork2 = (waitOptions = {}) => waitForSubmittedGpuWork(device, waitOptions);
-  function ensureFrameTelemetryResources() {
-    if (!frameTelemetryResources) {
-      frameTelemetryResources = createWavefrontFrameTelemetryResources({
+          maxRayCountRecords: tiles.length * config.samplesPerPixel * config.maxDepth
+        });
+      }
+      return frameTelemetryResources;
+    }, resolveRenderedSamplesPerPixel = function(renderOptions = {}, awaitGPUCompletion = true) {
+      return resolveWavefrontRenderedSamplesPerPixel({
+        config,
+        renderOptions,
+        awaitGPUCompletion,
+        lastCompletedFrameTimeMs,
+        lastCompletedSamplesPerPixel
+      });
+    }, createFrameStats = function({
+      frameIndex,
+      accelerationBuildSubmitted,
+      frameSubmissionCount,
+      parallelismCounters,
+      renderedSamplesPerPixel,
+      targetSamplesPerPixel,
+      frameTimeBudgetMs,
+      budgetConstrained
+    }) {
+      const stats = createWavefrontFrameStats({
+        config,
+        tiles,
+        frame,
+        frameIndex,
+        accelerationBuilt,
+        accelerationBuildCount,
+        accelerationBuildSubmitted,
+        frameSubmissionCount,
+        frameConfigSlotCount,
+        gpuAdapterParallelism,
+        parallelismCounters,
+        renderedSamplesPerPixel,
+        targetSamplesPerPixel,
+        frameTimeBudgetMs,
+        budgetConstrained
+      });
+      lastGpuParallelism = stats.gpuParallelism;
+      return stats.frameStats;
+    }, writeFrameConfigSlot = function(slot, tile, frameIndex, buildRange = {}) {
+      if (slot >= frameConfigSlotCount) {
+        throw new Error("Wavefront frame config slot capacity exceeded.");
+      }
+      const offset = slot * configBufferStride;
+      device.queue.writeBuffer(
+        configBuffer,
+        offset,
+        createConfigPayload(config, tile, frameIndex, buildRange)
+      );
+      return offset;
+    }, createFrameConfigWriter = function(frameIndex) {
+      let slot = 0;
+      return (tile, buildRange = {}) => {
+        const offset = writeFrameConfigSlot(slot, tile, frameIndex, buildRange);
+        slot += 1;
+        return offset;
+      };
+    }, dispatchGpuAccelerationBuild = function(frameIndex, parallelism) {
+      const submitted = dispatchWavefrontGpuAccelerationBuild({
+        config,
+        accelerationBuilt,
+        tiles,
         device,
-        constants,
-        maxRayCountRecords: tiles.length * config.samplesPerPixel * config.maxDepth
+        bvhBuildConfigBuffer,
+        configBufferStride,
+        bvhBuildBindGroup,
+        pipelines,
+        parallelism,
+        frameIndex
+      });
+      if (submitted) {
+        accelerationBuilt = true;
+        accelerationBuildCount += 1;
+      }
+      return submitted;
+    }, dispatchFrame = function(frameIndex, parallelism, renderedSamplesPerPixel = config.samplesPerPixel) {
+      return dispatchWavefrontFrame({
+        config,
+        tiles,
+        device,
+        frameIndex,
+        parallelism,
+        renderedSamplesPerPixel,
+        frameEncoder,
+        createFrameConfigWriter
+      });
+    }, renderOnce = function(renderOptions = {}, resolvedSamplingPlan = null) {
+      const frameStartTimeMs = nowMs3();
+      frame += 1;
+      const frameIndex = frame + config.frameIndex;
+      const samplingPlan = resolvedSamplingPlan ?? resolveRenderedSamplesPerPixel(renderOptions, false);
+      const parallelismCounters = createGpuParallelismCounters();
+      const accelerationBuildSubmitted = dispatchGpuAccelerationBuild(frameIndex, parallelismCounters);
+      const frameSubmissionCount = dispatchFrame(
+        frameIndex,
+        parallelismCounters,
+        samplingPlan.renderedSamplesPerPixel
+      );
+      const frameTimeMs = Math.max(0, nowMs3() - frameStartTimeMs);
+      return Object.freeze({
+        ...createFrameStats({
+          frameIndex,
+          accelerationBuildSubmitted,
+          frameSubmissionCount,
+          parallelismCounters,
+          renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel,
+          targetSamplesPerPixel: samplingPlan.targetSamplesPerPixel,
+          frameTimeBudgetMs: samplingPlan.frameTimeBudgetMs,
+          budgetConstrained: samplingPlan.budgetConstrained
+        }),
+        gpuWorkerJobs: createGpuWorkerJobDiagnostics(
+          lastGpuParallelism,
+          frameSubmissionCount + (accelerationBuildSubmitted ? 1 : 0),
+          frameTimeMs,
+          false
+        ),
+        timings: createWavefrontFrameTimingTelemetry({
+          status: "not-requested",
+          source: "cpu-submit",
+          timestampQueryStatus: "not-recorded",
+          totalRenderJobTimeMs: frameTimeMs
+        })
+      });
+    }, dispatchFrameAwaitingGpu = function(frameIndex, parallelism, renderedSamplesPerPixel = config.samplesPerPixel, optionsForFrame = {}) {
+      return dispatchWavefrontFrameAwaitingGpu({
+        config,
+        tiles,
+        device,
+        frameIndex,
+        parallelism,
+        renderedSamplesPerPixel,
+        frameEncoder,
+        writeFrameConfigSlot,
+        optionsForFrame
+      });
+    }, rebuildLiveConfig = function(overrides = {}) {
+      return createWavefrontPathTracingComputeConfig({
+        ...options,
+        canvas,
+        width: config.width,
+        height: config.height,
+        maxDepth: config.maxDepth,
+        tileSize: config.tileSize,
+        samplesPerPixel: config.samplesPerPixel,
+        sceneObjectCapacity: config.sceneObjectCapacity,
+        sceneObjects: packedScene.objects,
+        camera: activeCameraOptions,
+        environmentMap: {
+          ...config.environmentMap
+        },
+        strictPhysicalLowSppLighting: config.strictPhysicalLowSppLighting,
+        featureFlags: options.featureFlags,
+        frameIndex: config.frameIndex,
+        ...overrides
+      });
+    }, rebuildMediumResources = function(nextConfig) {
+      const previousMediumTextureResource = mediumTextureResource;
+      mediumTextureResource = createMediumTextureResource(device, constants, nextConfig.mediums);
+      bindGroups = createTraceBindGroups();
+      if (previousMediumTextureResource?.ownsTexture) {
+        previousMediumTextureResource.texture?.destroy?.();
+      }
+    }, updateSceneObjects = function(sceneObjects) {
+      progressive?.reset();
+      const nextPackedScene = packWavefrontSceneObjects(sceneObjects, config.sceneObjectCapacity);
+      packedScene = nextPackedScene;
+      const nextConfig = rebuildLiveConfig();
+      if (!mediumTablesEqual(config.mediums, nextConfig.mediums)) {
+        rebuildMediumResources(nextConfig);
+      }
+      config = nextConfig;
+      device.queue.writeBuffer(sceneObjectBuffer, 0, packedScene.buffer);
+      return config;
+    }, updateCamera = function(cameraOptions = {}) {
+      progressive?.reset();
+      activeCameraOptions = cameraOptions;
+      config = updateWavefrontCameraConfig(config, cameraOptions);
+      return config;
+    }, getSnapshot = function() {
+      return Object.freeze({
+        frame,
+        accumulatedSamplesPerPixel: progressive?.samples ?? 0,
+        width: config.width,
+        height: config.height,
+        maxDepth: config.maxDepth,
+        tiles: tiles.length,
+        tileSize: config.tileSize,
+        samplesPerPixel: config.samplesPerPixel,
+        maxFramePassesPerSubmission: config.maxFramePassesPerSubmission,
+        sceneObjectCount: config.sceneObjectCount,
+        triangleCount: config.triangleCount,
+        instanceCount: config.instancing?.instanceCount ?? 0,
+        geometryCount: config.instancing?.geometryCount ?? config.gpuMeshSource.meshes.count,
+        emissiveTriangleCount: config.emissiveTriangleCount,
+        environmentPortalCount: config.environmentPortalCount,
+        environmentPortalMode: config.environmentPortalMode,
+        mediumCount: config.mediumCount,
+        environmentMap: createEnvironmentMapSnapshot(config.environmentMap),
+        deferredPathResolve: config.deferredPathResolve,
+        strictPhysicalLowSppLighting: config.strictPhysicalLowSppLighting,
+        transportExperiments: config.transportExperiments,
+        transportExperimentFlags: config.transportExperimentFlags,
+        bvhNodeCount: config.bvhNodeCount,
+        displayQuality: config.displayQuality,
+        accelerationBuildMode: config.accelerationBuildMode,
+        gpuAccelerationBuildRequired: config.gpuAccelerationBuildRequired,
+        accelerationBuilt,
+        accelerationBuildCount,
+        frameConfigSlots: frameConfigSlotCount,
+        gpuParallelism: lastGpuParallelism,
+        memory: config.memory,
+        allocations: allocationTracker.snapshot()
+      });
+    }, destroy = function() {
+      progressive?.destroy();
+      frameTelemetryResources?.destroy?.();
+      activeQueue.destroy?.();
+      nextQueue.destroy?.();
+      hitBuffer.destroy?.();
+      accumulationBuffer.destroy?.();
+      pathVertexBuffer.destroy?.();
+      sceneObjectBuffer.destroy?.();
+      triangleBuffer.destroy?.();
+      instanceTexture?.destroy?.();
+      bvhNodeBuffer.destroy?.();
+      meshVertexBuffer.destroy?.();
+      meshIndexBuffer.destroy?.();
+      meshRangeBuffer.destroy?.();
+      environmentPortalBuffer.destroy?.();
+      bvhLeafRefBuffer.destroy?.();
+      configBuffer.destroy?.();
+      bvhBuildConfigBuffer.destroy?.();
+      counterBuffer.destroy?.();
+      activeDispatchBuffer.destroy?.();
+      radianceTexture.destroy?.();
+      denoiseScratchTexture.destroy?.();
+      outputTexture.destroy?.();
+      if (environmentMapResource.ownsTexture) {
+        environmentMapResource.texture?.destroy?.();
+      }
+      if (environmentSamplingResource.ownsTexture) {
+        environmentSamplingResource.texture?.destroy?.();
+      }
+      if (mediumTextureResource.ownsTexture) {
+        mediumTextureResource.texture?.destroy?.();
+      }
+      brdfLutResource.texture?.destroy?.();
+      if (baseColorAtlasResource.ownsTexture) {
+        baseColorAtlasResource.texture?.destroy?.();
+      }
+      if (metallicRoughnessAtlasResource.ownsTexture) {
+        metallicRoughnessAtlasResource.texture?.destroy?.();
+      }
+      if (normalAtlasResource.ownsTexture) {
+        normalAtlasResource.texture?.destroy?.();
+      }
+      if (occlusionAtlasResource.ownsTexture) {
+        occlusionAtlasResource.texture?.destroy?.();
+      }
+      if (emissiveAtlasResource.ownsTexture) {
+        emissiveAtlasResource.texture?.destroy?.();
+      }
+      Object.values(extensionAtlasResources).forEach((resource) => {
+        if (resource.ownsTexture) {
+          resource.texture?.destroy?.();
+        }
+      });
+      context.unconfigure?.();
+      allocationTracker.destroy();
+    };
+    finishAllocationScopes = openGpuAllocationErrorScopes(rawDevice);
+    const gpuAdapterParallelism = createGpuAdapterParallelismDiagnostics(adapter, device);
+    context = canvas.getContext("webgpu");
+    if (!context || typeof context.configure !== "function") {
+      throw new Error("Canvas WebGPU context does not support configure().");
+    }
+    const format = options.format ?? (typeof navigatorRef.gpu.getPreferredCanvasFormat === "function" ? navigatorRef.gpu.getPreferredCanvasFormat() : "bgra8unorm");
+    let config = initialConfig;
+    const safeTileSize = clampTileSizeForDevice(config, device);
+    if (safeTileSize !== config.tileSize) {
+      config = createWavefrontPathTracingComputeConfig({
+        ...options,
+        canvas,
+        width: config.width,
+        height: config.height,
+        tileSize: safeTileSize,
+        tilePixelCapacity: Math.min(
+          config.tilePixelCapacity,
+          safeTileSize * safeTileSize
+        )
       });
     }
-    return frameTelemetryResources;
-  }
-  function resolveRenderedSamplesPerPixel(renderOptions = {}, awaitGPUCompletion = true) {
-    return resolveWavefrontRenderedSamplesPerPixel({
-      config,
-      renderOptions,
-      awaitGPUCompletion,
-      lastCompletedFrameTimeMs,
-      lastCompletedSamplesPerPixel
+    config = Object.freeze({
+      ...config,
+      memory: estimateWavefrontPathTracingMemoryForConfig(config, device.limits)
+    });
+    canvas.width = config.width;
+    canvas.height = config.height;
+    context.configure({
+      device: rawDevice,
+      format,
+      alphaMode: options.alpha === true ? "premultiplied" : "opaque"
+    });
+    const bufferUsage = constants.buffer.STORAGE | constants.buffer.COPY_DST;
+    const memory = config.memory;
+    let instanceTexture = null, instanceView = null;
+    if (config.instancing) {
+      const count = config.instancing.instanceCount;
+      instanceTexture = device.createTexture({
+        label: "plasius.wavefront.instances",
+        size: { width: 9, height: count },
+        format: "rgba32uint",
+        usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
+      });
+      const upload = new Uint8Array(count * 256), source = new Uint8Array(config.instancing.buffer);
+      for (let i = 0; i < count; i++) upload.set(source.subarray(i * 144, (i + 1) * 144), i * 256);
+      device.queue.writeTexture({ texture: instanceTexture }, upload, { bytesPerRow: 256, rowsPerImage: count }, { width: 9, height: count, depthOrArrayLayers: 1 });
+      instanceView = instanceTexture.createView();
+    }
+    const activeQueue = createBuffer(device, bufferUsage, memory.queueBytes, "plasius.wavefront.activeQueue");
+    const nextQueue = createBuffer(device, bufferUsage, memory.queueBytes, "plasius.wavefront.nextQueue");
+    const hitBuffer = createBuffer(device, bufferUsage, memory.hitBytes, "plasius.wavefront.hitBuffer");
+    const accumulationBuffer = createBuffer(
+      device,
+      bufferUsage,
+      memory.accumulationBytes,
+      "plasius.wavefront.accumulation"
+    );
+    const pathVertexBuffer = createBuffer(
+      device,
+      bufferUsage,
+      memory.pathVertexBytes,
+      "plasius.wavefront.pathVertices"
+    );
+    const sceneObjectBuffer = createBuffer(
+      device,
+      constants.buffer.STORAGE | constants.buffer.COPY_DST,
+      memory.sceneObjectBytes,
+      "plasius.wavefront.sceneObjects"
+    );
+    const triangleBuffer = createBuffer(
+      device,
+      constants.buffer.STORAGE | constants.buffer.COPY_DST,
+      memory.triangleBytes,
+      "plasius.wavefront.triangles"
+    );
+    const bvhNodeBuffer = createBuffer(
+      device,
+      constants.buffer.STORAGE | constants.buffer.COPY_DST,
+      memory.bvhCombinedBytes,
+      "plasius.wavefront.bvhNodes"
+    );
+    const meshVertexBuffer = createBuffer(
+      device,
+      constants.buffer.STORAGE | constants.buffer.COPY_DST,
+      memory.meshVertexBytes,
+      "plasius.wavefront.meshVertices"
+    );
+    const meshIndexBuffer = createBuffer(
+      device,
+      constants.buffer.STORAGE | constants.buffer.COPY_DST,
+      memory.meshIndexBytes,
+      "plasius.wavefront.meshIndices"
+    );
+    const meshRangeBuffer = createBuffer(
+      device,
+      constants.buffer.STORAGE | constants.buffer.COPY_DST,
+      memory.meshRangeBytes,
+      "plasius.wavefront.meshRanges"
+    );
+    const environmentPortalBuffer = createBuffer(
+      device,
+      constants.buffer.STORAGE | constants.buffer.COPY_DST,
+      memory.environmentPortalBytes,
+      "plasius.wavefront.environmentPortals"
+    );
+    const bvhLeafRefBuffer = createBuffer(
+      device,
+      constants.buffer.STORAGE | constants.buffer.COPY_DST,
+      memory.bvhLeafReferenceBytes,
+      "plasius.wavefront.bvhLeafRefs"
+    );
+    const tiles = createTiles(config.width, config.height, config.tileSize);
+    const configBufferStride = memory.configBufferStride;
+    const outputConfigSlotCount = config.deferredPathResolve ? 0 : tiles.length;
+    const frameConfigSlotCount = Math.max(
+      1,
+      tiles.length * config.samplesPerPixel + outputConfigSlotCount + (config.denoise || config.progressive ? 1 : 0)
+    );
+    const configBuffer = createBuffer(
+      device,
+      constants.buffer.UNIFORM | constants.buffer.COPY_DST,
+      memory.frameConfigBytes,
+      "plasius.wavefront.frameConfig"
+    );
+    const bvhBuildConfigBuffer = createBuffer(
+      device,
+      constants.buffer.UNIFORM | constants.buffer.COPY_DST,
+      memory.bvhBuildConfigBytes,
+      "plasius.wavefront.bvhBuildConfig"
+    );
+    const counterBuffer = createBuffer(
+      device,
+      constants.buffer.STORAGE | constants.buffer.COPY_DST | constants.buffer.COPY_SRC,
+      memory.counterBytes,
+      "plasius.wavefront.counters"
+    );
+    const activeDispatchBuffer = createBuffer(
+      device,
+      constants.buffer.INDIRECT | constants.buffer.COPY_DST,
+      memory.indirectDispatchBytes,
+      "plasius.wavefront.activeDispatchArgs"
+    );
+    let packedScene = packWavefrontSceneObjects(config.sceneObjects, config.sceneObjectCapacity);
+    device.queue.writeBuffer(sceneObjectBuffer, 0, packedScene.buffer);
+    const packedTriangles = packWavefrontTriangles(
+      config.meshAcceleration.triangles,
+      Math.max(1, config.triangleCapacity)
+    );
+    const packedBvhNodes = packWavefrontBvhNodes(
+      config.meshAcceleration.nodes,
+      Math.max(1, config.bvhNodeCapacity + config.emissiveTriangleCapacity)
+    );
+    const packedBvhNodeUints = new Uint32Array(packedBvhNodes.buffer);
+    const packedBvhNodeFloats = new Float32Array(packedBvhNodes.buffer);
+    const orderedEmissiveTriangleIndices = resolveOrderedEmissiveTriangleIndices(config);
+    const emissiveWeights = orderedEmissiveTriangleIndices.map(
+      (triangleIndex) => emissiveTriangleWeight(config.meshAcceleration.triangles[triangleIndex])
+    );
+    const totalEmissiveWeight = emissiveWeights.reduce((total, weight) => total + weight, 0);
+    let cumulativeEmissiveWeight = 0;
+    orderedEmissiveTriangleIndices.forEach((triangleIndex, index) => {
+      const nodeOffset = (config.bvhNodeCapacity + index) * (BVH_NODE_RECORD_BYTES / 4);
+      cumulativeEmissiveWeight += emissiveWeights[index] ?? 0;
+      packedBvhNodeFloats[nodeOffset] = cumulativeEmissiveWeight;
+      packedBvhNodeFloats[nodeOffset + 1] = emissiveWeights[index] ?? 0;
+      packedBvhNodeFloats[nodeOffset + 2] = totalEmissiveWeight;
+      packedBvhNodeUints[nodeOffset + 8] = triangleIndex;
     });
-  }
-  function createFrameStats({
-    frameIndex,
-    accelerationBuildSubmitted,
-    frameSubmissionCount,
-    parallelismCounters,
-    renderedSamplesPerPixel,
-    targetSamplesPerPixel,
-    frameTimeBudgetMs,
-    budgetConstrained
-  }) {
-    const stats = createWavefrontFrameStats({
-      config,
-      tiles,
-      frame,
-      frameIndex,
-      accelerationBuilt,
-      accelerationBuildCount,
-      accelerationBuildSubmitted,
-      frameSubmissionCount,
-      frameConfigSlotCount,
-      gpuAdapterParallelism,
-      parallelismCounters,
-      renderedSamplesPerPixel,
-      targetSamplesPerPixel,
-      frameTimeBudgetMs,
-      budgetConstrained
+    await uploadWavefrontBuffer(device, triangleBuffer, packedTriangles.buffer);
+    await uploadWavefrontBuffer(device, bvhNodeBuffer, packedBvhNodes.buffer);
+    await uploadWavefrontBuffer(device, meshVertexBuffer, config.gpuMeshSource.vertices.buffer);
+    await uploadWavefrontBuffer(device, meshIndexBuffer, config.gpuMeshSource.indices.buffer);
+    await uploadWavefrontBuffer(device, meshRangeBuffer, config.gpuMeshSource.meshes.buffer);
+    const packedEnvironmentPortals = packEnvironmentPortals(
+      config.environmentPortals,
+      Math.max(1, config.environmentPortalCapacity)
+    );
+    device.queue.writeBuffer(environmentPortalBuffer, 0, packedEnvironmentPortals.buffer);
+    const radianceTexture = device.createTexture({
+      label: "plasius.wavefront.radiance",
+      size: { width: config.width, height: config.height },
+      format: "rgba16float",
+      usage: constants.texture.STORAGE_BINDING | constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST
     });
-    lastGpuParallelism = stats.gpuParallelism;
-    return stats.frameStats;
-  }
-  async function readTerminationMetrics() {
-    return readWavefrontTerminationMetrics({
+    const radianceView = radianceTexture.createView();
+    const denoiseScratchTexture = device.createTexture({
+      label: "plasius.wavefront.denoiseScratch",
+      size: { width: config.width, height: config.height },
+      format: "rgba16float",
+      usage: constants.texture.STORAGE_BINDING | constants.texture.TEXTURE_BINDING
+    });
+    const denoiseScratchView = denoiseScratchTexture.createView();
+    const outputTexture = device.createTexture({
+      label: "plasius.wavefront.output",
+      size: { width: config.width, height: config.height },
+      format: "rgba8unorm",
+      usage: constants.texture.STORAGE_BINDING | constants.texture.TEXTURE_BINDING | constants.texture.COPY_SRC
+    });
+    const outputView = outputTexture.createView();
+    const sampler = device.createSampler({
+      label: "plasius.wavefront.presentSampler",
+      magFilter: "nearest",
+      minFilter: "nearest"
+    });
+    const environmentMapResource = createEnvironmentMapResource(
       device,
       constants,
-      counterBuffer,
-      waitForSubmittedGpuWork: waitForSubmittedGpuWork2
-    });
-  }
-  function writeFrameConfigSlot(slot, tile, frameIndex, buildRange = {}) {
-    if (slot >= frameConfigSlotCount) {
-      throw new Error("Wavefront frame config slot capacity exceeded.");
-    }
-    const offset = slot * configBufferStride;
-    device.queue.writeBuffer(
-      configBuffer,
-      offset,
-      createConfigPayload(config, tile, frameIndex, buildRange)
+      config.environmentMap,
+      config.environmentColor
     );
-    return offset;
-  }
-  function createFrameConfigWriter(frameIndex) {
-    let slot = 0;
-    return (tile, buildRange = {}) => {
-      const offset = writeFrameConfigSlot(slot, tile, frameIndex, buildRange);
-      slot += 1;
-      return offset;
-    };
-  }
-  function dispatchGpuAccelerationBuild(frameIndex, parallelism) {
-    const submitted = dispatchWavefrontGpuAccelerationBuild({
-      config,
-      accelerationBuilt,
-      tiles,
+    const environmentSamplingResource = createEnvironmentSamplingTextureResource(
       device,
-      bvhBuildConfigBuffer,
-      configBufferStride,
-      bvhBuildBindGroup,
-      pipelines,
-      parallelism,
-      frameIndex
-    });
-    if (submitted) {
-      accelerationBuilt = true;
-      accelerationBuildCount += 1;
-    }
-    return submitted;
-  }
-  function dispatchFrame(frameIndex, parallelism, renderedSamplesPerPixel = config.samplesPerPixel) {
-    return dispatchWavefrontFrame({
-      config,
-      tiles,
+      constants,
+      config.environmentMap,
+      config.environmentColor
+    );
+    let mediumTextureResource = createMediumTextureResource(
       device,
-      frameIndex,
-      parallelism,
-      renderedSamplesPerPixel,
-      frameEncoder,
-      createFrameConfigWriter
-    });
-  }
-  function renderOnce(renderOptions = {}, resolvedSamplingPlan = null) {
-    const frameStartTimeMs = nowMs3();
-    frame += 1;
-    const frameIndex = frame + config.frameIndex;
-    const samplingPlan = resolvedSamplingPlan ?? resolveRenderedSamplesPerPixel(renderOptions, false);
-    const parallelismCounters = createGpuParallelismCounters();
-    const accelerationBuildSubmitted = dispatchGpuAccelerationBuild(frameIndex, parallelismCounters);
-    const frameSubmissionCount = dispatchFrame(
-      frameIndex,
-      parallelismCounters,
-      samplingPlan.renderedSamplesPerPixel
+      constants,
+      config.mediums
     );
-    const frameTimeMs = Math.max(0, nowMs3() - frameStartTimeMs);
-    return Object.freeze({
-      ...createFrameStats({
-        frameIndex,
-        accelerationBuildSubmitted,
-        frameSubmissionCount,
-        parallelismCounters,
-        renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel,
-        targetSamplesPerPixel: samplingPlan.targetSamplesPerPixel,
-        frameTimeBudgetMs: samplingPlan.frameTimeBudgetMs,
-        budgetConstrained: samplingPlan.budgetConstrained
-      }),
-      gpuWorkerJobs: createGpuWorkerJobDiagnostics(
-        lastGpuParallelism,
-        frameSubmissionCount + (accelerationBuildSubmitted ? 1 : 0),
-        frameTimeMs,
-        false
-      ),
-      timings: createWavefrontFrameTimingTelemetry({
-        status: "not-requested",
-        source: "cpu-submit",
-        timestampQueryStatus: "not-recorded",
-        totalRenderJobTimeMs: frameTimeMs
+    config = Object.freeze({
+      ...config,
+      environmentMap: Object.freeze({
+        ...config.environmentMap,
+        width: environmentMapResource.width,
+        height: environmentMapResource.height,
+        mipLevelCount: environmentMapResource.mipLevelCount,
+        hasImportanceData: environmentSamplingResource.hasImportanceData
       })
     });
-  }
-  function dispatchFrameAwaitingGpu(frameIndex, parallelism, renderedSamplesPerPixel = config.samplesPerPixel, optionsForFrame = {}) {
-    return dispatchWavefrontFrameAwaitingGpu({
-      config,
-      tiles,
+    const brdfLutResource = createBrdfLutResource(device, constants);
+    const baseColorAtlasResource = createAtlasTextureResource(
       device,
-      frameIndex,
-      parallelism,
-      renderedSamplesPerPixel,
-      frameEncoder,
-      writeFrameConfigSlot,
-      optionsForFrame
-    });
-  }
-  async function readOutputProbe(optionsForProbe = {}) {
-    return readWavefrontOutputProbe({
+      constants,
+      config.gpuMaterialSource.baseColorAtlas,
+      "plasius.wavefront.materialAtlas.baseColor"
+    );
+    const metallicRoughnessAtlasResource = createAtlasTextureResource(
       device,
       constants,
-      config,
-      outputTexture,
-      waitForSubmittedGpuWork: waitForSubmittedGpuWork2,
-      optionsForProbe
+      config.gpuMaterialSource.metallicRoughnessAtlas,
+      "plasius.wavefront.materialAtlas.metallicRoughness"
+    );
+    const normalAtlasResource = createAtlasTextureResource(
+      device,
+      constants,
+      config.gpuMaterialSource.normalAtlas,
+      "plasius.wavefront.materialAtlas.normal"
+    );
+    const occlusionAtlasResource = createAtlasTextureResource(
+      device,
+      constants,
+      config.gpuMaterialSource.occlusionAtlas,
+      "plasius.wavefront.materialAtlas.occlusion"
+    );
+    const emissiveAtlasResource = createAtlasTextureResource(
+      device,
+      constants,
+      config.gpuMaterialSource.emissiveAtlas,
+      "plasius.wavefront.materialAtlas.emissive"
+    );
+    const extensionAtlasNames = [
+      "clearcoat",
+      "clearcoatRoughness",
+      "clearcoatNormal",
+      "transmission",
+      "thickness",
+      "sheenColor",
+      "sheenRoughness",
+      "specular",
+      "specularColor",
+      "iridescence",
+      "iridescenceThickness",
+      "anisotropy"
+    ];
+    const extensionAtlasResources = Object.freeze(
+      Object.fromEntries(
+        extensionAtlasNames.map((name) => [
+          name,
+          createAtlasTextureResource(
+            device,
+            constants,
+            config.gpuMaterialSource.extensionAtlases[name],
+            `plasius.wavefront.materialAtlas.${name}`
+          )
+        ])
+      )
+    );
+    const materialAtlasSampler = device.createSampler({
+      label: "plasius.wavefront.materialAtlasSampler",
+      addressModeU: "clamp-to-edge",
+      addressModeV: "clamp-to-edge",
+      magFilter: "linear",
+      minFilter: "linear"
     });
-  }
-  async function renderFrame(renderOptions = {}) {
-    const awaitGPUCompletion = renderOptions.awaitGPUCompletion !== false;
-    const samplingPlan = resolveRenderedSamplesPerPixel(renderOptions, awaitGPUCompletion);
-    const useThrottledHighSamplePath = awaitGPUCompletion && samplingPlan.renderedSamplesPerPixel >= 8;
-    const telemetryRequested = renderOptions.readStats === true;
-    const telemetryCanRecord = telemetryRequested && awaitGPUCompletion;
-    const telemetryResourcesForFrame = telemetryCanRecord ? ensureFrameTelemetryResources() : null;
-    if (telemetryResourcesForFrame?.available) {
-      telemetryResourcesForFrame.beginFrame();
-      activeFrameTelemetry = telemetryResourcesForFrame;
-    }
-    const frameStartTimeMs = nowMs3();
-    let frameStats;
-    try {
-      if (useThrottledHighSamplePath) {
-        frame += 1;
-        const frameIndex = frame + config.frameIndex;
-        const parallelismCounters = createGpuParallelismCounters();
-        const accelerationBuildSubmitted = dispatchGpuAccelerationBuild(frameIndex, parallelismCounters);
-        let frameSubmissionCount = 0;
-        let frameConfigSlot = 0;
-        if (accelerationBuildSubmitted) {
-          const accelerationWaitOptions = {
-            ...estimateSubmittedGpuWorkTiming(
-              { ...config, renderedSamplesPerPixel: 1 },
-              1,
-              renderOptions.submittedWorkTimeoutMs,
-              { includeAccelerationBuild: true }
-            ),
-            allowTimeout: false
-          };
-          await waitForSubmittedGpuWork2(accelerationWaitOptions);
-        }
-        for (let tileIndex = 0; tileIndex < tiles.length; tileIndex += 1) {
-          const tileRangeDispatch = dispatchFrameAwaitingGpu(
-            frameIndex,
-            parallelismCounters,
-            samplingPlan.renderedSamplesPerPixel,
-            {
-              sampleRangeStart: 0,
-              sampleRangeEnd: samplingPlan.renderedSamplesPerPixel,
-              tileStartIndex: tileIndex,
-              tileEndIndex: tileIndex + 1,
-              startingSubmissionCount: frameSubmissionCount,
-              startingSlot: frameConfigSlot,
-              includeDenoise: tileIndex + 1 >= tiles.length,
-              includePresent: tileIndex + 1 >= tiles.length
-            }
-          );
-          frameSubmissionCount = tileRangeDispatch.submissionCount;
-          frameConfigSlot = tileRangeDispatch.slot;
-          const tileWaitOptions = {
-            ...estimateSubmittedGpuWorkTiming(
-              { ...config, renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel },
-              1,
-              renderOptions.submittedWorkTimeoutMs,
+    const {
+      bindGroupLayouts: {
+        trace: traceBindGroupLayout,
+        acceleration: accelerationBindGroupLayout,
+        denoiseRadiance: denoiseRadianceBindGroupLayout,
+        denoiseResolve: denoiseResolveBindGroupLayout,
+        present: presentBindGroupLayout
+      },
+      computePipelines: pipelines,
+      presentPipeline
+    } = await createWavefrontPipelineResources({ device, constants, format, instanced: !!config.instancing });
+    let bindGroups = createTraceBindGroups();
+    const bvhBuildBindGroup = createWavefrontBvhBuildBindGroup({
+      device,
+      accelerationBindGroupLayout,
+      bvhBuildConfigBuffer,
+      triangleBuffer,
+      bvhNodeBuffer,
+      meshVertexBuffer,
+      meshIndexBuffer,
+      meshRangeBuffer,
+      bvhLeafRefBuffer
+    });
+    const {
+      radiance: denoiseRadianceBindGroup,
+      resolve: denoiseResolveBindGroup,
+      directResolve: denoiseDirectResolveBindGroup
+    } = createWavefrontDenoiseBindGroups({
+      device,
+      denoiseRadianceBindGroupLayout,
+      denoiseResolveBindGroupLayout,
+      configBuffer,
+      radianceView,
+      denoiseScratchView,
+      outputView
+    });
+    const presentBindGroup = createWavefrontPresentBindGroup({
+      device,
+      presentBindGroupLayout,
+      outputView,
+      sampler
+    });
+    const progressive = await createWavefrontProgressiveResources({ device, constants, config, configBuffer, radianceTexture, radianceView, outputView });
+    let activeFrameTelemetry = null;
+    let frameTelemetryResources = null;
+    const frameEncoder = createWavefrontFrameEncoder({
+      getConfig: () => config,
+      progressive,
+      getBindGroups: () => bindGroups,
+      pipelines,
+      counterBuffer,
+      activeDispatchBuffer,
+      denoiseRadianceBindGroup,
+      denoiseResolveBindGroup,
+      denoiseDirectResolveBindGroup,
+      presentPipeline,
+      presentBindGroup,
+      context,
+      getFrameTelemetry: () => activeFrameTelemetry
+    });
+    let frame = 0;
+    let accelerationBuilt = !config.gpuAccelerationBuildRequired;
+    let accelerationBuildCount = 0;
+    let activeCameraOptions = options.camera ?? DEFAULT_CAMERA2;
+    let lastCompletedFrameTimeMs = null;
+    let lastCompletedSamplesPerPixel = Math.max(1, config.samplesPerPixel);
+    let lastGpuParallelism = createGpuParallelismDiagnostics(
+      gpuAdapterParallelism,
+      createGpuParallelismCounters()
+    );
+    const waitForSubmittedGpuWork2 = (waitOptions = {}) => waitForSubmittedGpuWork(device, waitOptions);
+    async function readTerminationMetrics() {
+      return readWavefrontTerminationMetrics({
+        device,
+        constants,
+        counterBuffer,
+        waitForSubmittedGpuWork: waitForSubmittedGpuWork2
+      });
+    }
+    async function readOutputProbe(optionsForProbe = {}) {
+      return readWavefrontOutputProbe({
+        device,
+        constants,
+        config,
+        outputTexture,
+        waitForSubmittedGpuWork: waitForSubmittedGpuWork2,
+        optionsForProbe
+      });
+    }
+    async function renderFrame(renderOptions = {}) {
+      const awaitGPUCompletion = renderOptions.awaitGPUCompletion !== false;
+      const samplingPlan = resolveRenderedSamplesPerPixel(renderOptions, awaitGPUCompletion);
+      const useThrottledHighSamplePath = awaitGPUCompletion && samplingPlan.renderedSamplesPerPixel >= 8;
+      const telemetryRequested = renderOptions.readStats === true;
+      const telemetryCanRecord = telemetryRequested && awaitGPUCompletion;
+      const telemetryResourcesForFrame = telemetryCanRecord ? ensureFrameTelemetryResources() : null;
+      if (telemetryResourcesForFrame?.available) {
+        telemetryResourcesForFrame.beginFrame();
+        activeFrameTelemetry = telemetryResourcesForFrame;
+      }
+      const frameStartTimeMs = nowMs3();
+      let frameStats;
+      try {
+        if (useThrottledHighSamplePath) {
+          frame += 1;
+          const frameIndex = frame + config.frameIndex;
+          const parallelismCounters = createGpuParallelismCounters();
+          const accelerationBuildSubmitted = dispatchGpuAccelerationBuild(frameIndex, parallelismCounters);
+          let frameSubmissionCount = 0;
+          let frameConfigSlot = 0;
+          if (accelerationBuildSubmitted) {
+            const accelerationWaitOptions = {
+              ...estimateSubmittedGpuWorkTiming(
+                { ...config, renderedSamplesPerPixel: 1 },
+                1,
+                renderOptions.submittedWorkTimeoutMs,
+                { includeAccelerationBuild: true }
+              ),
+              allowTimeout: false
+            };
+            await waitForSubmittedGpuWork2(accelerationWaitOptions);
+          }
+          for (let tileIndex = 0; tileIndex < tiles.length; tileIndex += 1) {
+            const tileRangeDispatch = dispatchFrameAwaitingGpu(
+              frameIndex,
+              parallelismCounters,
+              samplingPlan.renderedSamplesPerPixel,
               {
-                includeDenoise: tileIndex + 1 >= tiles.length && config.denoise,
+                sampleRangeStart: 0,
+                sampleRangeEnd: samplingPlan.renderedSamplesPerPixel,
+                tileStartIndex: tileIndex,
+                tileEndIndex: tileIndex + 1,
+                startingSubmissionCount: frameSubmissionCount,
+                startingSlot: frameConfigSlot,
+                includeDenoise: tileIndex + 1 >= tiles.length,
                 includePresent: tileIndex + 1 >= tiles.length
               }
-            ),
+            );
+            frameSubmissionCount = tileRangeDispatch.submissionCount;
+            frameConfigSlot = tileRangeDispatch.slot;
+            const tileWaitOptions = {
+              ...estimateSubmittedGpuWorkTiming(
+                { ...config, renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel },
+                1,
+                renderOptions.submittedWorkTimeoutMs,
+                {
+                  includeDenoise: tileIndex + 1 >= tiles.length && config.denoise,
+                  includePresent: tileIndex + 1 >= tiles.length
+                }
+              ),
+              allowTimeout: false
+            };
+            await waitForSubmittedGpuWork2(tileWaitOptions);
+          }
+          frameStats = createFrameStats({
+            frameIndex,
+            accelerationBuildSubmitted,
+            frameSubmissionCount,
+            parallelismCounters,
+            renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel,
+            targetSamplesPerPixel: samplingPlan.targetSamplesPerPixel,
+            frameTimeBudgetMs: samplingPlan.frameTimeBudgetMs,
+            budgetConstrained: samplingPlan.budgetConstrained
+          });
+        } else {
+          const submittedWorkTiming = estimateSubmittedGpuWorkTiming(
+            { ...config, renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel },
+            tiles.length,
+            renderOptions.submittedWorkTimeoutMs,
+            { includeAccelerationBuild: config.gpuAccelerationBuildRequired && !accelerationBuilt }
+          );
+          const submissionWaitOptions = awaitGPUCompletion ? {
+            timeoutMs: submittedWorkTiming.timeoutMs,
+            maxWaitMs: submittedWorkTiming.maxWaitMs,
             allowTimeout: false
+          } : {
+            timeoutMs: submittedWorkTiming.timeoutMs,
+            maxWaitMs: submittedWorkTiming.maxWaitMs
           };
-          await waitForSubmittedGpuWork2(tileWaitOptions);
-        }
-        frameStats = createFrameStats({
-          frameIndex,
-          accelerationBuildSubmitted,
-          frameSubmissionCount,
-          parallelismCounters,
-          renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel,
-          targetSamplesPerPixel: samplingPlan.targetSamplesPerPixel,
-          frameTimeBudgetMs: samplingPlan.frameTimeBudgetMs,
-          budgetConstrained: samplingPlan.budgetConstrained
-        });
-      } else {
-        const submittedWorkTiming = estimateSubmittedGpuWorkTiming(
-          { ...config, renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel },
-          tiles.length,
-          renderOptions.submittedWorkTimeoutMs,
-          { includeAccelerationBuild: config.gpuAccelerationBuildRequired && !accelerationBuilt }
-        );
-        const submissionWaitOptions = awaitGPUCompletion ? {
-          timeoutMs: submittedWorkTiming.timeoutMs,
-          maxWaitMs: submittedWorkTiming.maxWaitMs,
-          allowTimeout: false
-        } : {
-          timeoutMs: submittedWorkTiming.timeoutMs,
-          maxWaitMs: submittedWorkTiming.maxWaitMs
-        };
-        frameStats = renderOnce(renderOptions, samplingPlan);
-        if (awaitGPUCompletion) {
-          await waitForSubmittedGpuWork2(submissionWaitOptions);
+          frameStats = renderOnce(renderOptions, samplingPlan);
+          if (awaitGPUCompletion) {
+            await waitForSubmittedGpuWork2(submissionWaitOptions);
+          }
         }
+      } finally {
+        activeFrameTelemetry = null;
       }
-    } finally {
-      activeFrameTelemetry = null;
-    }
-    const frameTimeMs = Math.max(0, nowMs3() - frameStartTimeMs);
-    if (awaitGPUCompletion) {
-      lastCompletedFrameTimeMs = frameTimeMs;
-      lastCompletedSamplesPerPixel = frameStats.renderedSamplesPerPixel ?? frameStats.samplesPerPixel;
-    }
-    const expectedPrimaryRays = config.width * config.height * samplingPlan.renderedSamplesPerPixel;
-    const expectedRayCounts = tiles.length * samplingPlan.renderedSamplesPerPixel * config.maxDepth;
-    const telemetryReadback = telemetryCanRecord ? await telemetryResourcesForFrame.readFrame({
-      expectedPrimaryRays,
-      expectedRayCounts,
-      waitForSubmittedGpuWork: waitForSubmittedGpuWork2
-    }) : null;
-    const rayCounts = !telemetryRequested ? createWavefrontRayCountTelemetry() : !awaitGPUCompletion ? createWavefrontRayCountTelemetry({
-      status: "unavailable",
-      expectedPrimaryRays,
-      expectedRayCounts,
-      reason: "gpu-work-not-awaited"
-    }) : telemetryReadback.rayCounts;
-    const timings = !telemetryRequested ? createWavefrontFrameTimingTelemetry({
-      status: "not-requested",
-      source: awaitGPUCompletion ? "queue-completion" : "cpu-submit",
-      timestampQueryStatus: "not-recorded",
-      totalRenderJobTimeMs: frameTimeMs
-    }) : !awaitGPUCompletion ? createWavefrontFrameTimingTelemetry({
-      status: "unavailable",
-      source: "cpu-submit",
-      timestampQueryStatus: "not-recorded",
-      totalRenderJobTimeMs: frameTimeMs,
-      reason: "gpu-work-not-awaited"
-    }) : telemetryReadback.timestampQueryStatus === "available" ? createWavefrontFrameTimingTelemetry({
-      status: "available",
-      source: "timestamp-query",
-      timestampQueryStatus: "available",
-      totalGpuTimeMs: telemetryReadback.totalGpuTimeMs,
-      totalRenderJobTimeMs: frameTimeMs
-    }) : createWavefrontFrameTimingTelemetry({
-      status: "fallback",
-      source: "queue-completion",
-      timestampQueryStatus: telemetryReadback.timestampQueryStatus,
-      totalRenderJobTimeMs: frameTimeMs,
-      reason: telemetryReadback.reason
-    });
-    const deviceLossStatus = awaitGPUCompletion ? "not-detected" : typeof device.lost?.then === "function" ? "pending" : "not-exposed";
-    frameStats = Object.freeze({
-      ...frameStats,
-      deviceLossStatus,
-      secondaryRays: rayCounts.status === "available" ? rayCounts.secondaryRays : null,
-      totalPathSegments: rayCounts.status === "available" ? rayCounts.totalPathSegments : null,
-      rayCounts,
-      timings,
-      telemetryMemoryBytes: telemetryResourcesForFrame?.memoryBytes ?? 0,
-      gpuWorkerJobs: createGpuWorkerJobDiagnostics(
-        frameStats.gpuParallelism,
-        frameStats.commandSubmissions,
-        frameTimeMs,
-        awaitGPUCompletion
-      )
-    });
-    const terminationMetrics = awaitGPUCompletion && renderOptions.readStats === true ? await readTerminationMetrics() : EMPTY_TERMINATION_METRICS;
-    const probe = renderOptions.readOutputProbe === false ? null : await readOutputProbe(renderOptions.probe);
-    const maxChannel = probe ? Math.max(...probe.rgba.slice(0, 3)) : 0;
-    const completedFrame = Object.freeze({
-      ...frameStats,
-      outputProbe: probe ? Object.freeze({
-        ...probe,
-        sampledPixels: 1,
-        nonZeroSamples: maxChannel > 0 ? 1 : 0,
-        maxChannel
-      }) : null,
-      bounces: [],
-      termination: terminationMetrics.termination,
-      terminalRadiance: terminationMetrics.terminalRadiance,
-      radianceDiagnostics: terminationMetrics.radianceDiagnostics,
-      transportContributions: terminationMetrics.transportContributions,
-      queueOverflow: terminationMetrics.queueOverflow
-    });
+      const frameTimeMs = Math.max(0, nowMs3() - frameStartTimeMs);
+      if (awaitGPUCompletion) {
+        lastCompletedFrameTimeMs = frameTimeMs;
+        lastCompletedSamplesPerPixel = frameStats.renderedSamplesPerPixel ?? frameStats.samplesPerPixel;
+      }
+      const expectedPrimaryRays = config.width * config.height * samplingPlan.renderedSamplesPerPixel;
+      const expectedRayCounts = tiles.length * samplingPlan.renderedSamplesPerPixel * config.maxDepth;
+      const telemetryReadback = telemetryCanRecord ? await telemetryResourcesForFrame.readFrame({
+        expectedPrimaryRays,
+        expectedRayCounts,
+        waitForSubmittedGpuWork: waitForSubmittedGpuWork2
+      }) : null;
+      const rayCounts = !telemetryRequested ? createWavefrontRayCountTelemetry() : !awaitGPUCompletion ? createWavefrontRayCountTelemetry({
+        status: "unavailable",
+        expectedPrimaryRays,
+        expectedRayCounts,
+        reason: "gpu-work-not-awaited"
+      }) : telemetryReadback.rayCounts;
+      const timings = !telemetryRequested ? createWavefrontFrameTimingTelemetry({
+        status: "not-requested",
+        source: awaitGPUCompletion ? "queue-completion" : "cpu-submit",
+        timestampQueryStatus: "not-recorded",
+        totalRenderJobTimeMs: frameTimeMs
+      }) : !awaitGPUCompletion ? createWavefrontFrameTimingTelemetry({
+        status: "unavailable",
+        source: "cpu-submit",
+        timestampQueryStatus: "not-recorded",
+        totalRenderJobTimeMs: frameTimeMs,
+        reason: "gpu-work-not-awaited"
+      }) : telemetryReadback.timestampQueryStatus === "available" ? createWavefrontFrameTimingTelemetry({
+        status: "available",
+        source: "timestamp-query",
+        timestampQueryStatus: "available",
+        totalGpuTimeMs: telemetryReadback.totalGpuTimeMs,
+        totalRenderJobTimeMs: frameTimeMs
+      }) : createWavefrontFrameTimingTelemetry({
+        status: "fallback",
+        source: "queue-completion",
+        timestampQueryStatus: telemetryReadback.timestampQueryStatus,
+        totalRenderJobTimeMs: frameTimeMs,
+        reason: telemetryReadback.reason
+      });
+      const deviceLossStatus = awaitGPUCompletion ? "not-detected" : typeof device.lost?.then === "function" ? "pending" : "not-exposed";
+      frameStats = Object.freeze({
+        ...frameStats,
+        deviceLossStatus,
+        secondaryRays: rayCounts.status === "available" ? rayCounts.secondaryRays : null,
+        totalPathSegments: rayCounts.status === "available" ? rayCounts.totalPathSegments : null,
+        rayCounts,
+        timings,
+        telemetryMemoryBytes: telemetryResourcesForFrame?.memoryBytes ?? 0,
+        gpuWorkerJobs: createGpuWorkerJobDiagnostics(
+          frameStats.gpuParallelism,
+          frameStats.commandSubmissions,
+          frameTimeMs,
+          awaitGPUCompletion
+        )
+      });
+      const terminationMetrics = awaitGPUCompletion && renderOptions.readStats === true ? await readTerminationMetrics() : EMPTY_TERMINATION_METRICS;
+      const probe = renderOptions.readOutputProbe === false ? null : await readOutputProbe(renderOptions.probe);
+      const maxChannel = probe ? Math.max(...probe.rgba.slice(0, 3)) : 0;
+      const completedFrame = Object.freeze({
+        ...frameStats,
+        outputProbe: probe ? Object.freeze({
+          ...probe,
+          sampledPixels: 1,
+          nonZeroSamples: maxChannel > 0 ? 1 : 0,
+          maxChannel
+        }) : null,
+        bounces: [],
+        termination: terminationMetrics.termination,
+        terminalRadiance: terminationMetrics.terminalRadiance,
+        radianceDiagnostics: terminationMetrics.radianceDiagnostics,
+        transportContributions: terminationMetrics.transportContributions,
+        queueOverflow: terminationMetrics.queueOverflow
+      });
+      return Object.freeze({
+        ...completedFrame,
+        transportGuardrails: createWavefrontTransportGuardrailSummary(completedFrame)
+      });
+    }
+    await finishAllocationScopes();
     return Object.freeze({
-      ...completedFrame,
-      transportGuardrails: createWavefrontTransportGuardrailSummary(completedFrame)
-    });
-  }
-  function rebuildLiveConfig(overrides = {}) {
-    return createWavefrontPathTracingComputeConfig({
-      ...options,
       canvas,
-      width: config.width,
-      height: config.height,
-      maxDepth: config.maxDepth,
-      tileSize: config.tileSize,
-      samplesPerPixel: config.samplesPerPixel,
-      sceneObjectCapacity: config.sceneObjectCapacity,
-      sceneObjects: packedScene.objects,
-      camera: activeCameraOptions,
-      environmentMap: {
-        ...config.environmentMap
-      },
-      strictPhysicalLowSppLighting: config.strictPhysicalLowSppLighting,
-      featureFlags: options.featureFlags,
-      frameIndex: config.frameIndex,
-      ...overrides
+      context,
+      device: rawDevice,
+      format,
+      config,
+      renderOnce,
+      renderFrame,
+      readOutputProbe,
+      updateSceneObjects,
+      updateCamera,
+      resetAccumulation: () => progressive?.reset(),
+      getSnapshot,
+      destroy
     });
-  }
-  function rebuildMediumResources(nextConfig) {
-    const previousMediumTextureResource = mediumTextureResource;
-    mediumTextureResource = createMediumTextureResource(device, constants, nextConfig.mediums);
-    bindGroups = createTraceBindGroups();
-    if (previousMediumTextureResource?.ownsTexture) {
-      previousMediumTextureResource.texture?.destroy?.();
-    }
-  }
-  function updateSceneObjects(sceneObjects) {
-    progressive?.reset();
-    const nextPackedScene = packWavefrontSceneObjects(sceneObjects, config.sceneObjectCapacity);
-    packedScene = nextPackedScene;
-    const nextConfig = rebuildLiveConfig();
-    if (!mediumTablesEqual(config.mediums, nextConfig.mediums)) {
-      rebuildMediumResources(nextConfig);
+  } catch (error) {
+    try {
+      await finishAllocationScopes?.();
+    } catch {
     }
-    config = nextConfig;
-    device.queue.writeBuffer(sceneObjectBuffer, 0, packedScene.buffer);
-    return config;
-  }
-  function updateCamera(cameraOptions = {}) {
-    progressive?.reset();
-    activeCameraOptions = cameraOptions;
-    config = updateWavefrontCameraConfig(config, cameraOptions);
-    return config;
-  }
-  function getSnapshot() {
-    return Object.freeze({
-      frame,
-      accumulatedSamplesPerPixel: progressive?.samples ?? 0,
-      width: config.width,
-      height: config.height,
-      maxDepth: config.maxDepth,
-      tiles: tiles.length,
-      tileSize: config.tileSize,
-      samplesPerPixel: config.samplesPerPixel,
-      maxFramePassesPerSubmission: config.maxFramePassesPerSubmission,
-      sceneObjectCount: config.sceneObjectCount,
-      triangleCount: config.triangleCount,
-      emissiveTriangleCount: config.emissiveTriangleCount,
-      environmentPortalCount: config.environmentPortalCount,
-      environmentPortalMode: config.environmentPortalMode,
-      mediumCount: config.mediumCount,
-      environmentMap: createEnvironmentMapSnapshot(config.environmentMap),
-      deferredPathResolve: config.deferredPathResolve,
-      strictPhysicalLowSppLighting: config.strictPhysicalLowSppLighting,
-      transportExperiments: config.transportExperiments,
-      transportExperimentFlags: config.transportExperimentFlags,
-      bvhNodeCount: config.bvhNodeCount,
-      displayQuality: config.displayQuality,
-      accelerationBuildMode: config.accelerationBuildMode,
-      gpuAccelerationBuildRequired: config.gpuAccelerationBuildRequired,
-      accelerationBuilt,
-      accelerationBuildCount,
-      frameConfigSlots: frameConfigSlotCount,
-      gpuParallelism: lastGpuParallelism,
-      memory: config.memory
-    });
-  }
-  function destroy() {
-    progressive?.destroy();
-    frameTelemetryResources?.destroy?.();
-    activeQueue.destroy?.();
-    nextQueue.destroy?.();
-    hitBuffer.destroy?.();
-    accumulationBuffer.destroy?.();
-    pathVertexBuffer.destroy?.();
-    sceneObjectBuffer.destroy?.();
-    triangleBuffer.destroy?.();
-    bvhNodeBuffer.destroy?.();
-    meshVertexBuffer.destroy?.();
-    meshIndexBuffer.destroy?.();
-    meshRangeBuffer.destroy?.();
-    environmentPortalBuffer.destroy?.();
-    bvhLeafRefBuffer.destroy?.();
-    configBuffer.destroy?.();
-    bvhBuildConfigBuffer.destroy?.();
-    counterBuffer.destroy?.();
-    activeDispatchBuffer.destroy?.();
-    radianceTexture.destroy?.();
-    denoiseScratchTexture.destroy?.();
-    outputTexture.destroy?.();
-    if (environmentMapResource.ownsTexture) {
-      environmentMapResource.texture?.destroy?.();
-    }
-    if (environmentSamplingResource.ownsTexture) {
-      environmentSamplingResource.texture?.destroy?.();
-    }
-    if (mediumTextureResource.ownsTexture) {
-      mediumTextureResource.texture?.destroy?.();
-    }
-    brdfLutResource.texture?.destroy?.();
-    if (baseColorAtlasResource.ownsTexture) {
-      baseColorAtlasResource.texture?.destroy?.();
-    }
-    if (metallicRoughnessAtlasResource.ownsTexture) {
-      metallicRoughnessAtlasResource.texture?.destroy?.();
-    }
-    if (normalAtlasResource.ownsTexture) {
-      normalAtlasResource.texture?.destroy?.();
-    }
-    if (occlusionAtlasResource.ownsTexture) {
-      occlusionAtlasResource.texture?.destroy?.();
-    }
-    if (emissiveAtlasResource.ownsTexture) {
-      emissiveAtlasResource.texture?.destroy?.();
-    }
-    Object.values(extensionAtlasResources).forEach((resource) => {
-      if (resource.ownsTexture) {
-        resource.texture?.destroy?.();
-      }
-    });
-    context.unconfigure?.();
+    context?.unconfigure?.();
+    allocationTracker.destroy();
+    rawDevice.destroy?.();
+    throw error;
   }
-  return Object.freeze({
-    canvas,
-    context,
-    device,
-    format,
-    config,
-    renderOnce,
-    renderFrame,
-    readOutputProbe,
-    updateSceneObjects,
-    updateCamera,
-    resetAccumulation: () => progressive?.reset(),
-    getSnapshot,
-    destroy
-  });
 }
 async function renderWavefrontPathTracingComputeFrame(options = {}) {
   const renderer = await createWavefrontPathTracingComputeRenderer(options);