@forgeax/engine-render 0.1.28 → 0.1.30

package/dist/{chunk-VSL23LZE.mjs → chunk-C3DDSXYK.mjs}

@@ -1,20 +1,172 @@
 import { GlyphText } from './chunk-ILQ5MEZF.mjs';
-import { MeshRenderer, MeshFilter, DirectionalLight, validateDirectionalLightData, PointLight, computeInvRangeSquared, SpotLight, degToCos, RectAreaLight, validateRectAreaLightData, directionalShadowQualityFromF32, PointLightShadow, Skylight, LightProbe, validateLightProbeData, SkyboxBackground, Atmosphere, Instances, Layer, Points, Lines, SortKey, resolveMeshMaterialBindings, pointShapeFromU32, PostProcessParams, CubeCamera, cubeCameraUpdateIntentFromF32, ReflectionProbe, reflectionProbeUpdateIntentFromF32, tonemapToU32, resolveVisibility, Fog, VolumetricFog, resolveSelectedVolumetricLight, extractVolumetricFog, MotionBlur, Camera, bloomEnabledFromF32, antialiasFromF32, tonemapFromF32, cameraProjectionFromF32 } from './chunk-JAASCMXA.mjs';
-import { SpriteRegionOverride, SpriteInstances, selectActiveCameraIndex, getActiveCamera } from './chunk-RBDBZ5R7.mjs';
-import { PROBE_BLEND_RECORD_CAPACITY, GPU_BUFFER_USAGE_MAP_READ, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_COPY_DST, IES_SLICE_CAPACITY, COOKIE_SLICE_CAPACITY, isStandardPbrSkinMaterialShader, selectPasses, resolveRenderTargetMaterialSource, PROBE_BLEND_RECORD_BYTE_SIZE, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, COOKIE_SLICE_SIZE, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader } from './chunk-IQMKJLNU.mjs';
-import { STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, SHADOW_ATLAS_DEFAULT_LAYERS, SkinMaterialMismatchError, MaterialSkinAttrMissingError, ShadowInvalidConfigError, EnvironmentSourceConflictError, FogCardinalityError, AtmosphereInvalidParameterError } from './chunk-J6KACNOH.mjs';
-import { err, ok, RhiError } from '@forgeax/engine-rhi';
+import { MeshRenderer, MeshFilter, DirectionalLight, validateDirectionalLightData, PointLight, computeInvRangeSquared, SpotLight, degToCos, RectAreaLight, validateRectAreaLightData, directionalShadowQualityFromF32, PointLightShadow, Skylight, LightProbe, validateLightProbeData, SkyboxBackground, Atmosphere, Instances, Layer, Points, Lines, SortKey, resolveMeshMaterialBindings, pointShapeFromU32, PostProcessParams, buildCubeCameraFaceViews, CubeCamera, cubeCameraUpdateIntentFromF32, ReflectionProbe, reflectionProbeUpdateIntentFromF32, tonemapToU32, resolveVisibility, Fog, VolumetricFog, resolveSelectedVolumetricLight, extractVolumetricFog, MotionBlur, DynamicResolution, ScreenSpaceReflection, Camera, CAMERA_EXPOSURE_MODE_MANUAL, cameraExposureFromColumns, antialiasFromF32, validateDynamicResolutionCamera, bloomEnabledFromF32, tonemapFromF32, cameraProjectionFromF32 } from './chunk-S5UE2T5P.mjs';
+import { SpriteRegionOverride, SpriteInstances, selectActiveCameraIndex, getActiveCamera } from './chunk-PA5DRJNI.mjs';
+import { PROBE_BLEND_RECORD_CAPACITY, GPU_BUFFER_USAGE_MAP_READ, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_COPY_DST, gpuDrivenShadowDrawKey, IES_SLICE_CAPACITY, COOKIE_SLICE_CAPACITY, isStandardPbrSkinMaterialShader, buildGpuDrivenDraws, worldEntityKey, gpuDrivenSourceDrawItemIndex, selectPasses, resolveRenderTargetMaterialSource, isCanonicalStandardPbrMaterialShader, PROBE_BLEND_RECORD_BYTE_SIZE, GPU_BUFFER_USAGE_UNIFORM, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, COOKIE_SLICE_SIZE, isStandardPbrMaterialShader } from './chunk-FUUO4UND.mjs';
+import { STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, SHADOW_ATLAS_DEFAULT_LAYERS, SkinMaterialMismatchError, MaterialSkinAttrMissingError, InstanceCollectionError, ShadowInvalidConfigError, EnvironmentSourceConflictError, FogCardinalityError, GPU_TEXTURE_USAGE_COPY_SRC, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_STORAGE_BINDING, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, AtmosphereInvalidParameterError } from './chunk-JRBDO2KB.mjs';
+import { R_MIN, ok, err, TextError, toShared, handleSlot, AssetError, ASSET_ERROR_HINTS, materialValuesToLinearRuntime, derive, unpackSlot, materialGuidText } from '@forgeax/engine-types';
+import { err as err$1, ok as ok$1, RhiError } from '@forgeax/engine-rhi';
 import { resolveAssetHandle, walkMaterialPassesOverSharedRefs, selectMaterialPassProgram, materialParametersToParamSchema as materialParametersToParamSchema$1 } from '@forgeax/engine-assets-runtime';
-import { SpawnLightInvalidBoundsError, routeWorldError, SpriteInstancesMutuallyExclusiveWithInstancesError, SpriteInstancesRequiresSpriteShaderError, SpriteInstancesCountMismatchError, InstanceTransformsStrideMismatchError, readRenderArrayView } from '@forgeax/engine-ecs/projection';
+import { SpawnLightInvalidBoundsError, routeWorldError, SpriteInstancesMutuallyExclusiveWithInstancesError, SpriteInstancesRequiresSpriteShaderError, SpriteInstancesCountMismatchError, readRenderArrayView } from '@forgeax/engine-ecs/projection';
 import { vec3, mat4, frustum, box3 } from '@forgeax/engine-math';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
 import { Transform, GlobalTransform, MorphWeights } from '@forgeax/engine-scene';
-import { STANDARD_PIPELINE_PARAM_SCHEMA, DEFAULT_STANDARD_SURFACE_MODULE } from '@forgeax/engine-shader';
-import { R_MIN, err as err$1, ok as ok$1, TextError, toShared, handleSlot, AssetError, ASSET_ERROR_HINTS, materialValuesToLinearRuntime, derive, unpackSlot, materialGuidText } from '@forgeax/engine-types';
-import { PROCEDURAL_FLOATS_PER_VERTEX, deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import { standardTextureMask, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, STANDARD_PIPELINE_PARAM_SCHEMA, DEFAULT_STANDARD_SURFACE_MODULE } from '@forgeax/engine-shader';
 import { Skin, SkinInstancesCoexistForbiddenError, SkeletonResolveFailedError, JointCountMismatchError, JointEntityDanglingError } from '@forgeax/engine-skinning';
+import { PROCEDURAL_FLOATS_PER_VERTEX } from '@forgeax/engine-geometry';
 import { resetFontConcurrency, trackFontConcurrency, layoutGlyphText, conservativeCubeAabb, bakeGlyphMesh } from '@forgeax/engine-graphics-extras';
 
+// src/ssr/hiz.ts
+var SSR_HIZ_FORMAT = "r32float";
+function validExtent(extent) {
+  return Number.isInteger(extent.width) && Number.isInteger(extent.height) && extent.width > 0 && extent.height > 0;
+}
+function requireExtent(extent) {
+  if (!validExtent(extent)) {
+    throw new RangeError("SSR Hi-Z extent must contain positive integer width and height");
+  }
+}
+function nextSsrHiZMipExtent(extent) {
+  requireExtent(extent);
+  return {
+    width: Math.max(1, Math.floor(extent.width / 2)),
+    height: Math.max(1, Math.floor(extent.height / 2))
+  };
+}
+function buildSsrHiZPlan(extent) {
+  requireExtent(extent);
+  const levels = [];
+  let current = { width: extent.width, height: extent.height };
+  let level = 0;
+  while (true) {
+    levels.push({ level, ...current });
+    if (current.width === 1 && current.height === 1) break;
+    current = nextSsrHiZMipExtent(current);
+    level += 1;
+  }
+  return Object.freeze({
+    extent: Object.freeze({ width: extent.width, height: extent.height }),
+    format: SSR_HIZ_FORMAT,
+    mipLevelCount: levels.length,
+    levels: Object.freeze(levels.map((entry) => Object.freeze(entry))),
+    graphSize: Object.freeze({ width: extent.width, height: extent.height })
+  });
+}
+
+// src/ssr/resources.ts
+var SSR_TRACE_FORMAT = "rgba16float";
+var SSR_R32FLOAT_BYTES_PER_PIXEL = 4;
+var SSR_RGBA16FLOAT_BYTES_PER_PIXEL = 8;
+var SSR_TEMPORAL_PARAMS_BYTES = 32;
+var SSR_SPATIAL_MEMORY_BUDGET_BYTES = 45088768;
+function halfExtent(extent) {
+  return {
+    width: Math.max(1, Math.floor(extent.width / 2)),
+    height: Math.max(1, Math.floor(extent.height / 2))
+  };
+}
+function byteCount(width, height, bytesPerPixel) {
+  const bytes = width * height * bytesPerPixel;
+  if (!Number.isSafeInteger(bytes)) {
+    throw new RangeError("SSR spatial descriptor byte count exceeds safe integer range");
+  }
+  return bytes;
+}
+function estimateSsrSpatialMemory(extent, options = {}) {
+  const half = halfExtent(extent);
+  const plan = buildSsrHiZPlan(half);
+  const temporal = options.temporal !== false;
+  const hizBytes = plan.levels.reduce(
+    (sum, level) => sum + byteCount(level.width, level.height, SSR_R32FLOAT_BYTES_PER_PIXEL),
+    0
+  );
+  const traceBytes = byteCount(half.width, half.height, SSR_RGBA16FLOAT_BYTES_PER_PIXEL);
+  const hitReactivityBytes = byteCount(half.width, half.height, SSR_R32FLOAT_BYTES_PER_PIXEL);
+  const resolvedBytes = temporal ? plan.levels.reduce(
+    (sum, level) => sum + byteCount(level.width, level.height, SSR_RGBA16FLOAT_BYTES_PER_PIXEL),
+    0
+  ) : 0;
+  const historyBytes = temporal ? half.width * half.height * 12 * 2 : 0;
+  const temporalParamsBytes = temporal ? SSR_TEMPORAL_PARAMS_BYTES : 0;
+  const fallbackInputBytes = byteCount(
+    extent.width,
+    extent.height,
+    SSR_RGBA16FLOAT_BYTES_PER_PIXEL
+  );
+  const ssrOwnedBytes = hizBytes + traceBytes + hitReactivityBytes + resolvedBytes + historyBytes + temporalParamsBytes + fallbackInputBytes;
+  return Object.freeze({
+    width: extent.width,
+    height: extent.height,
+    halfWidth: half.width,
+    halfHeight: half.height,
+    hizBytes,
+    traceBytes,
+    hitReactivityBytes,
+    resolvedBytes,
+    historyBytes,
+    temporalParamsBytes,
+    fallbackInputBytes,
+    ssrOwnedBytes,
+    budgetBytes: SSR_SPATIAL_MEMORY_BUDGET_BYTES,
+    withinBudget: ssrOwnedBytes <= SSR_SPATIAL_MEMORY_BUDGET_BYTES
+  });
+}
+function texture(graph, label, format, extent) {
+  const created = graph.createTexture(label, {
+    format,
+    size: { width: extent.width, height: extent.height },
+    domain: "linear-hdr"
+  });
+  if (!created.ok) return created;
+  const view = graph.view(created.value, { label: `${label}.view`, dimension: "2d" });
+  if (!view.ok) return view;
+  return ok({
+    texture: created.value,
+    view: view.value,
+    width: extent.width,
+    height: extent.height,
+    format
+  });
+}
+function createSsrHiZResources(graph, extent) {
+  const plan = buildSsrHiZPlan(halfExtent(extent));
+  const created = graph.createTexture("ssr-hiz", {
+    format: SSR_HIZ_FORMAT,
+    size: plan.graphSize,
+    mipLevelCount: plan.mipLevelCount
+  });
+  if (!created.ok) return created;
+  const levels = [];
+  for (const entry of plan.levels) {
+    const view = graph.view(created.value, {
+      label: `ssr-hiz.mip-${entry.level}.view`,
+      dimension: "2d",
+      baseMipLevel: entry.level,
+      mipLevelCount: 1
+    });
+    if (!view.ok) return view;
+    levels.push(view.value);
+  }
+  return ok({ plan, texture: created.value, levels: Object.freeze(levels) });
+}
+function createSsrSpatialResources(graph, extent) {
+  const hiz = createSsrHiZResources(graph, extent);
+  if (!hiz.ok) return hiz;
+  const traceExtent = halfExtent(extent);
+  const trace = texture(graph, "ssr-trace", SSR_TRACE_FORMAT, traceExtent);
+  if (!trace.ok) return trace;
+  const hitTexture = graph.createTexture("ssr-hit-reactivity", {
+    format: "r32float",
+    size: traceExtent
+  });
+  if (!hitTexture.ok) return hitTexture;
+  const hitReactivity = graph.view(hitTexture.value, {
+    label: "ssr-hit-reactivity.view",
+    dimension: "2d"
+  });
+  if (!hitReactivity.ok) return hitReactivity;
+  return ok({ hiz: hiz.value, trace: trace.value, hitReactivity: hitReactivity.value });
+}
+
 // src/inspection-types.ts
 function projectLightInspection(input) {
   return Object.freeze({
@@ -87,6 +239,293 @@ function projectExtendedLightingInspection(state) {
     uploadBytes: state.descriptorBytes
   });
 }
+var SSR_HISTORY_FORMAT = "rgba16float";
+var HISTORY_USAGE = GPU_TEXTURE_USAGE_COPY_SRC | GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING | GPU_TEXTURE_USAGE_STORAGE_BINDING | GPU_TEXTURE_USAGE_RENDER_ATTACHMENT;
+function positiveDimension(value, field) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new RangeError(`${field} must be a positive safe integer.`);
+  }
+  return value;
+}
+function createResources(device, scope, width, height) {
+  const halfWidth = Math.max(1, Math.floor(width / 2));
+  const halfHeight = Math.max(1, Math.floor(height / 2));
+  const descriptor = {
+    label: "ssr-history-rgba16float",
+    size: { width: halfWidth, height: halfHeight, depthOrArrayLayers: 1 },
+    format: SSR_HISTORY_FORMAT,
+    usage: HISTORY_USAGE,
+    mipLevelCount: 1,
+    sampleCount: 1,
+    dimension: "2d",
+    viewFormats: void 0,
+    textureBindingViewDimension: void 0
+  };
+  const childScope = scope.createChild(`${scope.owner}:ssr-history`);
+  const slots = [];
+  for (const index of [0, 1]) {
+    const texture2 = device.createTexture({
+      ...descriptor,
+      label: `ssr-history-rgba16float-${index}`
+    });
+    if (!texture2.ok) {
+      childScope.abandon();
+      return texture2;
+    }
+    childScope._adopt("texture", texture2.value, (value) => {
+      device.destroyTexture(value);
+    });
+    const view = device.createTextureView(texture2.value, {
+      label: `ssr-history-rgba16float-${index}.view`,
+      dimension: "2d",
+      baseMipLevel: 0,
+      mipLevelCount: 1,
+      baseArrayLayer: 0,
+      arrayLayerCount: 1
+    });
+    if (!view.ok) {
+      childScope.abandon();
+      return view;
+    }
+    const surfaceTexture = device.createTexture({
+      ...descriptor,
+      label: `ssr-history-surface-${index}`,
+      format: "rgba8unorm"
+    });
+    if (!surfaceTexture.ok) {
+      childScope.abandon();
+      return surfaceTexture;
+    }
+    childScope._adopt("texture", surfaceTexture.value, (value) => {
+      device.destroyTexture(value);
+    });
+    const surfaceView = device.createTextureView(surfaceTexture.value, { dimension: "2d" });
+    if (!surfaceView.ok) {
+      childScope.abandon();
+      return surfaceView;
+    }
+    slots.push({
+      texture: texture2.value,
+      view: view.value,
+      surfaceTexture: surfaceTexture.value,
+      surfaceView: surfaceView.value
+    });
+  }
+  const params = device.createBuffer({
+    label: "ssr-temporal-params",
+    size: 32,
+    usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+    mappedAtCreation: false
+  });
+  if (!params.ok) {
+    childScope.abandon();
+    return params;
+  }
+  childScope._adopt("buffer", params.value, (value) => {
+    device.destroyBuffer(value);
+  });
+  const cleared = device.queue.writeBuffer(params.value, 0, new Uint8Array(32));
+  if (!cleared.ok) {
+    childScope.abandon();
+    return cleared;
+  }
+  return ok({
+    width,
+    height,
+    halfWidth,
+    halfHeight,
+    bytes: halfWidth * halfHeight * 12 * 2,
+    descriptor,
+    slots,
+    paramsBuffer: params.value,
+    childScope
+  });
+}
+function failure(code, expected, hint, detail) {
+  return { code, expected, hint, ...{}  };
+}
+var SsrHistoryOwner = class _SsrHistoryOwner {
+  constructor(device, scope, resources) {
+    this.device = device;
+    this.scope = scope;
+    this.activeResources = resources;
+  }
+  device;
+  scope;
+  activeResources;
+  retiringResources = /* @__PURE__ */ new Set();
+  retirementFencePending = false;
+  activeCandidate;
+  readIndex = 0;
+  valid = false;
+  state = "first-frame";
+  resetReason = "first-enable";
+  lastFailure;
+  resetCount = 0;
+  static create(input) {
+    const width = positiveDimension(input.width, "width");
+    const height = positiveDimension(input.height, "height");
+    const resources = createResources(input.device, input.scope, width, height);
+    return resources.ok ? ok(new _SsrHistoryOwner(input.device, input.scope, resources.value)) : resources;
+  }
+  get resources() {
+    if (this.activeResources === void 0) throw new Error("SSR history resources are retired.");
+    return this.activeResources;
+  }
+  beginFrame() {
+    if (this.activeResources === void 0 || this.state === "retired" || this.state === "disposed") {
+      return err(
+        failure(
+          "ssr-history-retired",
+          "SSR history resources are active",
+          "recreate the renderer-owned SSR history after device recovery"
+        )
+      );
+    }
+    if (this.activeCandidate !== void 0) {
+      return err(
+        failure(
+          "ssr-history-active",
+          "one SSR history candidate is active",
+          "commit or abort the active SSR history candidate before beginning another"
+        )
+      );
+    }
+    const writeSlot = this.valid ? this.readIndex === 0 ? 1 : 0 : 0;
+    const candidate = Object.freeze({
+      readSlot: this.valid ? this.readIndex : null,
+      writeSlot,
+      historyValid: this.valid && this.resetReason === void 0
+    });
+    this.activeCandidate = candidate;
+    this.state = this.valid ? "stable" : this.state === "aborted" ? "aborted" : "first-frame";
+    this.lastFailure = void 0;
+    return ok(candidate);
+  }
+  commitFrame(candidate) {
+    if (this.activeCandidate !== candidate) {
+      return err(
+        failure(
+          "ssr-history-not-active",
+          "commit the candidate returned by beginFrame",
+          "keep one candidate from beginFrame until the shared queue submit succeeds"
+        )
+      );
+    }
+    this.readIndex = candidate.writeSlot;
+    this.valid = true;
+    this.activeCandidate = void 0;
+    this.state = "stable";
+    this.resetReason = void 0;
+    this.lastFailure = void 0;
+    return ok(void 0);
+  }
+  abortFrame(candidate, stage) {
+    if (this.activeCandidate !== candidate) return;
+    this.activeCandidate = void 0;
+    this.state = "aborted";
+    this.lastFailure = stage;
+  }
+  reset(reason) {
+    this.activeCandidate = void 0;
+    this.valid = false;
+    this.readIndex = 0;
+    this.resetReason = reason;
+    this.lastFailure = void 0;
+    this.resetCount += 1;
+    if (this.activeResources !== void 0) this.state = "reset";
+  }
+  resize(width, height) {
+    const next = createResources(
+      this.device,
+      this.scope,
+      positiveDimension(width, "width"),
+      positiveDimension(height, "height")
+    );
+    if (!next.ok) return next;
+    if (this.activeResources !== void 0) this.retiringResources.add(this.activeResources);
+    this.activeResources = next.value;
+    this.activeCandidate = void 0;
+    this.valid = false;
+    this.readIndex = 0;
+    this.resetReason = "resize";
+    this.lastFailure = void 0;
+    this.resetCount += 1;
+    this.state = "reset";
+    return ok(void 0);
+  }
+  /** Retire pending allocations after the queue's already-submitted work. */
+  retireAfterFence(queue, onFailure) {
+    if (this.retirementFencePending) return;
+    if (this.retiringResources.size === 0 && this.activeResources !== void 0) {
+      this.retiringResources.add(this.activeResources);
+      this.activeCandidate = void 0;
+      this.valid = false;
+      this.state = "retiring";
+    }
+    const pending = [...this.retiringResources];
+    for (const resources of pending) resources.childScope.beginRetire();
+    if (pending.length === 0) return;
+    this.retirementFencePending = true;
+    const finish = () => {
+      this.retirementFencePending = false;
+      for (const resources of pending) {
+        this.retiringResources.delete(resources);
+        resources.childScope.retire();
+        if (this.activeResources === resources) this.activeResources = void 0;
+      }
+      if (this.activeResources === void 0 && this.retiringResources.size === 0) {
+        this.state = "retired";
+      }
+      if (this.retiringResources.size > 0) this.retireAfterFence(queue, onFailure);
+    };
+    void queue.onSubmittedWorkDone().then(finish, (cause) => {
+      onFailure(cause);
+      finish();
+    });
+  }
+  retire() {
+    this.retirementFencePending = false;
+    this.activeCandidate = void 0;
+    if (this.activeResources !== void 0) {
+      this.activeResources.childScope.retire();
+      this.activeResources = void 0;
+    }
+    for (const resources of this.retiringResources) resources.childScope.retire();
+    this.retiringResources.clear();
+    this.valid = false;
+    this.state = "retired";
+  }
+  dispose() {
+    if (this.state === "disposed") return;
+    this.retire();
+    this.state = "disposed";
+  }
+  inspect() {
+    const active = this.activeResources;
+    return Object.freeze({
+      state: this.state,
+      width: active?.width ?? 0,
+      height: active?.height ?? 0,
+      halfWidth: active?.halfWidth ?? 0,
+      halfHeight: active?.halfHeight ?? 0,
+      format: SSR_HISTORY_FORMAT,
+      historyCount: active === void 0 ? 0 : 2,
+      historyValid: this.valid,
+      readSlot: active === void 0 ? null : this.valid ? this.readIndex : null,
+      writeSlot: active === void 0 ? 0 : this.valid ? this.readIndex === 0 ? 1 : 0 : 0,
+      activeBytes: active?.bytes ?? 0,
+      candidateBytes: 0,
+      retiringBytes: [...this.retiringResources].filter((entry) => entry !== active).reduce((sum, entry) => sum + entry.bytes, 0),
+      resetCount: this.resetCount,
+      resetReason: this.resetReason,
+      lastFailure: this.lastFailure
+    });
+  }
+};
+function createSsrHistoryOwner(input) {
+  return SsrHistoryOwner.create(input);
+}
 
 // src/scene/visibility/occlusion-query-pool.ts
 var OCCLUSION_QUERY_PAGE_COUNT = 3;
@@ -229,7 +668,7 @@ function createOcclusionQueryResources(device, pageIndex) {
     device.destroyQuerySet(querySet.value);
     return stagingBuffer;
   }
-  return ok({
+  return ok$1({
     pageIndex,
     querySet: querySet.value,
     resolveBuffer: resolveBuffer.value,
@@ -238,7 +677,7 @@ function createOcclusionQueryResources(device, pageIndex) {
 }
 function recordOcclusionResolve(encoder, resources, firstQuery, queryCount) {
   if (!Number.isSafeInteger(firstQuery) || !Number.isSafeInteger(queryCount) || firstQuery < 0 || queryCount <= 0 || firstQuery + queryCount > OCCLUSION_QUERY_PAGE_INDEX_LIMIT) {
-    return err(
+    return err$1(
       new RhiError({
         code: "webgpu-runtime-error",
         expected: "query range stays within one 4096-index page",
@@ -255,7 +694,7 @@ function recordOcclusionResolve(encoder, resources, firstQuery, queryCount) {
   );
   if (!resolved.ok) return resolved;
   encoder.copyBufferToBuffer(resources.resolveBuffer, resources.stagingBuffer, queryCount * 8);
-  return ok(void 0);
+  return ok$1(void 0);
 }
 
 // src/scene/visibility/types.ts
@@ -310,19 +749,19 @@ var OcclusionRenderRuntime = class {
       },
       encodeProxyBounds: (pass) => {
         const pending = runtime.pendingFrame;
-        return pending === void 0 ? err(runtimeError("the current RenderSystem frame owns the occlusion candidate")) : runtime.encodeProxyBounds(pass, pending);
+        return pending === void 0 ? err$1(runtimeError("the current RenderSystem frame owns the occlusion candidate")) : runtime.encodeProxyBounds(pass, pending);
       },
       beginCandidate: (pass) => {
         const pending = runtime.pendingFrame;
         if (pending === void 0 || pending.endedCount >= pending.reservations.length) {
-          return err(runtimeError("the current RenderSystem frame owns the occlusion candidate"));
+          return err$1(runtimeError("the current RenderSystem frame owns the occlusion candidate"));
         }
         return pass.beginOcclusionQuery(pending.reservations[pending.endedCount]?.queryIndex ?? 0);
       },
       endCandidate: (pass) => {
         const pending = runtime.pendingFrame;
         if (pending === void 0 || pending.endedCount >= pending.reservations.length) {
-          return err(runtimeError("the current RenderSystem frame owns the occlusion candidate"));
+          return err$1(runtimeError("the current RenderSystem frame owns the occlusion candidate"));
         }
         const ended = pass.endOcclusionQuery();
         if (ended.ok) pending.endedCount += 1;
@@ -331,7 +770,7 @@ var OcclusionRenderRuntime = class {
       recordResolve: (encoder) => {
         const pending = runtime.pendingFrame;
         if (pending === void 0 || pending.endedCount !== pending.reservations.length) {
-          return err(runtimeError("the real geometry pass must end its occlusion query first"));
+          return err$1(runtimeError("the real geometry pass must end its occlusion query first"));
         }
         return recordOcclusionResolve(
           encoder,
@@ -665,7 +1104,7 @@ var OcclusionRenderRuntime = class {
   }
   encodeProxyBounds(pass, pending) {
     if (pending.proxyFloatCount === 0) {
-      return err(runtimeError("every occlusion candidate needs conservative proxy geometry"));
+      return err$1(runtimeError("every occlusion candidate needs conservative proxy geometry"));
     }
     const pipeline = this.ensureProxyPipeline(pending.sampleCount);
     if (pipeline === void 0) {
@@ -676,11 +1115,11 @@ var OcclusionRenderRuntime = class {
         if (!ended.ok) return ended;
       }
       pending.endedCount = pending.reservations.length;
-      return ok(void 0);
+      return ok$1(void 0);
     }
     const buffer = this.ensureProxyBuffer(pending.proxyFloatCount * Float32Array.BYTES_PER_ELEMENT);
     if (buffer === void 0) {
-      return err(runtimeError("the backend must allocate the bounded proxy geometry buffer"));
+      return err$1(runtimeError("the backend must allocate the bounded proxy geometry buffer"));
     }
     const uploaded = this.device.queue.writeBuffer(
       buffer,
@@ -702,7 +1141,7 @@ var OcclusionRenderRuntime = class {
       vertexOffset += vertices.length;
     }
     pending.endedCount = pending.reservations.length;
-    return ok(void 0);
+    return ok$1(void 0);
   }
   ensureProxyBuffer(byteLength) {
     if (this.proxyBuffer !== void 0) return this.proxyBuffer;
@@ -909,27 +1348,27 @@ function freezeFog(candidate) {
 }
 function selectEnvironment(input) {
   if (input.environments.length > 1) {
-    return err$1(
+    return err(
       new EnvironmentSourceConflictError(
         [...input.environments].sort((left, right) => left.entityKey - right.entityKey).map(({ kind, entityKey, sourceKey }) => ({ kind, entityKey, sourceKey }))
       )
     );
   }
-  if (input.fogs.length > 1) return err$1(new FogCardinalityError(input.fogs.length));
+  if (input.fogs.length > 1) return err(new FogCardinalityError(input.fogs.length));
   const selectedFog = input.fogs[0];
   if (selectedFog !== void 0) {
     const issue = validateFogParameters(selectedFog);
     if (issue !== void 0) {
-      return err$1(new EnvironmentSelectionParameterError(issue.field, issue.value, issue.expected));
+      return err(new EnvironmentSelectionParameterError(issue.field, issue.value, issue.expected));
     }
   }
   const selected = input.environments[0];
   if (selected?.kind === "atmosphere") {
     const invalid = validateAtmosphereParameters(selected.atmosphere);
-    if (invalid !== void 0) return err$1(invalid);
+    if (invalid !== void 0) return err(invalid);
   }
   if (selected?.kind === "atmosphere" && input.suns.length !== 1) {
-    return err$1(new SunCardinalityError(input.suns.length));
+    return err(new SunCardinalityError(input.suns.length));
   }
   const source = selected === void 0 ? { kind: "none" } : selected.kind === "atmosphere" ? {
     kind: "atmosphere",
@@ -957,7 +1396,7 @@ function selectEnvironment(input) {
     sun
   };
   Object.defineProperty(result, "lane", { value: input.lane, enumerable: false });
-  return ok$1(Object.freeze(result));
+  return ok(Object.freeze(result));
 }
 
 // src/extract/directional-shadow-projection.ts
@@ -988,208 +1427,6 @@ function projectDirectionalShadow(fits, mapSize, shadowFilter, shadowAngularRadi
   }
   return { splitPlanes, directionalShadowQuality };
 }
-
-// src/errors/gpu-driven.ts
-var ERROR_POLICY = {
-  "missing-material-receipt": {
-    expected: "a producer-owned Standard PBR material receipt is present",
-    hint: "cook and load the Standard PBR artifact, then retry preparation"
-  },
-  "missing-uv": {
-    expected: "the geometry exposes every UV set named by the material receipt",
-    hint: "repair the geometry UV semantic or route the draw to the CPU semantic lane"
-  },
-  "reflection-mismatch": {
-    expected: "the loaded reflection receipt matches the artifact layout identity",
-    hint: "rebuild the material artifact and reflection from one source, then retry"
-  },
-  "vertex-input-mismatch": {
-    expected: "geometry vertex semantics match the material reflection receipt",
-    hint: "repair the geometry vertex semantic layout or route the draw to the CPU lane"
-  },
-  "alpha-mask-mismatch": {
-    expected: "the Alpha Mask cutoff is present in the material receipt",
-    hint: "declare alphaCutoff in the Standard PBR material schema and recook it"
-  },
-  "resource-not-ready": {
-    expected: "all material resource slots have resolved handles",
-    hint: "resolve the declared texture and sampler resources before recording"
-  },
-  "stale-generation": {
-    expected: "receipt and prepared inputs belong to the requested generation",
-    hint: "discard stale GPU facts, rebuild the producer receipt, and retry the same draw"
-  },
-  "skin-receipt-mismatch": {
-    expected: "skinned geometry has a current palette address receipt",
-    hint: "rebuild the Skin palette receipt for this generation before recording"
-  }
-};
-var GpuDrivenPreparationError = class extends Error {
-  code;
-  expected;
-  hint;
-  detail;
-  constructor(code, detail) {
-    const policy = ERROR_POLICY[code];
-    super(`[GpuDrivenPreparationError ${code}] ${policy.expected}`);
-    this.name = "GpuDrivenPreparationError";
-    this.code = code;
-    this.expected = policy.expected;
-    this.hint = policy.hint;
-    this.detail = detail;
-  }
-};
-
-// src/gpu-driven/prepared-draw.ts
-function failure(code, detail) {
-  return { ok: false, error: new GpuDrivenPreparationError(code, detail) };
-}
-function sameVertexInputs(expected, actual) {
-  return expected.length === actual.length && expected.every(
-    (input, index) => input.semantic === actual[index]?.semantic && input.location === actual[index]?.location && input.format === actual[index]?.format
-  );
-}
-function hasMaterialResources(snapshot, receipt) {
-  const textures = snapshot.material.textureHandles;
-  const samplers = snapshot.material.samplerHandles;
-  return receipt.resourceSlots.every((slot) => {
-    const handles = slot.kind === "texture" ? textures : samplers;
-    return handles?.has(slot.parameter) === true;
-  });
-}
-function prepareGpuDrivenDraw(input) {
-  const receipt = input.artifact.receipt;
-  if (receipt === void 0) {
-    return failure("missing-material-receipt", {
-      reason: "material-receipt-missing",
-      owner: "material",
-      expected: "MaterialShaderArtifact.receipt"
-    });
-  }
-  if (receipt.generation !== input.generation) {
-    return failure("stale-generation", {
-      reason: "generation-stale",
-      owner: "generation",
-      expectedGeneration: input.generation,
-      actualGeneration: receipt.generation
-    });
-  }
-  if (receipt.reflection.layoutIdentity !== input.artifact.layoutIdentity) {
-    return failure("reflection-mismatch", {
-      reason: "reflection-receipt-mismatch",
-      owner: "material",
-      expected: input.artifact.layoutIdentity,
-      actual: receipt.reflection.layoutIdentity
-    });
-  }
-  if (receipt.uvSets.some((uv) => uv.set > 0) && input.geometry.vertexInputs.length < 3) {
-    return failure("missing-uv", {
-      reason: "uv-set-missing",
-      owner: "geometry",
-      expected: `${receipt.uvSets.length} material UV sets`,
-      actual: `${input.geometry.vertexInputs.filter((vertex) => vertex.semantic.startsWith("uv")).length} geometry UV sets`
-    });
-  }
-  if (!sameVertexInputs(receipt.vertexInputs, input.geometry.vertexInputs)) {
-    return failure("vertex-input-mismatch", {
-      reason: "vertex-semantic-mismatch",
-      owner: "geometry",
-      expected: receipt.vertexInputs.map((input2) => input2.semantic).join(","),
-      actual: input.geometry.vertexInputs.map((input2) => input2.semantic).join(",")
-    });
-  }
-  if (receipt.alphaMask.cutoff.length === 0) {
-    return failure("alpha-mask-mismatch", {
-      reason: "alpha-mask-receipt-missing",
-      owner: "material",
-      expected: "alphaMask.cutoff"
-    });
-  }
-  if (!hasMaterialResources(input.snapshot, receipt)) {
-    return failure("resource-not-ready", {
-      reason: "material-resource-missing",
-      owner: "material",
-      expected: receipt.resourceSlots.map((slot) => slot.parameter).join(",")
-    });
-  }
-  const deformation = input.snapshot.skin === void 0 ? "rigid" : "skin";
-  if (deformation === "skin") {
-    if (input.skinReceipt === void 0 || receipt.skinPaletteAddress === void 0) {
-      return failure("skin-receipt-mismatch", {
-        reason: "skin-address-missing",
-        owner: "skin",
-        expected: "skinPaletteAddress and skinReceipt"
-      });
-    }
-    if (input.skinReceipt.generation !== input.generation || input.skinReceipt.group !== receipt.skinPaletteAddress.group || input.skinReceipt.binding !== receipt.skinPaletteAddress.binding) {
-      return failure("skin-receipt-mismatch", {
-        reason: "skin-address-missing",
-        owner: "skin",
-        expected: `${receipt.skinPaletteAddress.group}:${receipt.skinPaletteAddress.binding}@${input.generation}`,
-        actual: `${input.skinReceipt.group}:${input.skinReceipt.binding}@${input.skinReceipt.generation}`
-      });
-    }
-  }
-  return {
-    ok: true,
-    value: {
-      identity: {
-        material: input.artifact.material,
-        geometry: input.geometry.identity,
-        deformation
-      },
-      receiptGeneration: receipt.generation,
-      directEntry: receipt.directEntry,
-      sceneIndexEntry: receipt.sceneIndexEntry,
-      materialRow: receipt.materialRow,
-      resourceSlots: receipt.resourceSlots,
-      uvSets: receipt.uvSets,
-      vertexInputs: receipt.vertexInputs,
-      alphaMask: receipt.alphaMask,
-      skinPaletteAddress: receipt.skinPaletteAddress,
-      topology: input.draw.topology,
-      indexed: input.draw.kind === "indexed",
-      first: input.draw.first,
-      count: input.draw.count,
-      baseVertex: input.draw.baseVertex
-    }
-  };
-}
-
-// src/extract/gpu-driven.ts
-function resolvePreparedGpuDrivenDraw(input) {
-  return prepareGpuDrivenDraw(input);
-}
-function gpuDrivenMaterialResourceClass(material) {
-  const textures = [...material.textureHandles?.entries() ?? []].map(([name, handle]) => [name, Number(handle)]).sort(([left], [right]) => left.localeCompare(right));
-  const samplers = [...material.samplerHandles?.entries() ?? []].map(([name, handle]) => [name, Number(handle)]).sort(([left], [right]) => left.localeCompare(right));
-  return JSON.stringify({
-    textures,
-    samplers,
-    video: [...material.videoTextureFields?.keys() ?? []].sort()
-  });
-}
-function buildGpuDrivenDraws(input) {
-  let nonIndexedFirst = 0;
-  return input.submeshes.flatMap((submesh) => {
-    const drawMaterial = input.materials[submesh.materialSlot] ?? input.fallbackMaterial;
-    const first = input.indexed ? submesh.indexOffset : nonIndexedFirst;
-    nonIndexedFirst += submesh.vertexCount;
-    if (drawMaterial.transparent === true) return [];
-    const draw = {
-      kind: input.indexed ? "indexed" : "non-indexed",
-      first,
-      count: input.indexed ? submesh.indexCount : submesh.vertexCount,
-      baseVertex: 0,
-      materialSlot: submesh.materialSlot,
-      topology: submesh.topology,
-      pipelineClass: `${drawMaterial.materialShaderId ?? "forgeax::default-unlit"}|${submesh.topology}|${JSON.stringify(drawMaterial.renderState ?? null)}`,
-      materialResourceClass: gpuDrivenMaterialResourceClass(drawMaterial)
-    };
-    const prepared = input.prepare?.(draw, drawMaterial);
-    return [prepared === void 0 ? draw : { ...draw, prepared }];
-  });
-}
 var bakeCache = /* @__PURE__ */ new WeakMap();
 var materialCache = /* @__PURE__ */ new WeakMap();
 var liveGlyphSlots = /* @__PURE__ */ new WeakMap();
@@ -1252,8 +1489,8 @@ function glyphTextLayoutSystem(world, gpuStore) {
     const error = processEntity(world, gpuStore, entity);
     if (error !== null && firstError === null) firstError = error;
   }
-  if (firstError !== null) return err$1(firstError);
-  return ok$1(void 0);
+  if (firstError !== null) return err(firstError);
+  return ok(void 0);
 }
 function collectGlyphEntities(world) {
   const entities = [];
@@ -1421,13 +1658,15 @@ function signatureOf(gt) {
 function asFontHandle(raw) {
   return toShared(raw);
 }
+
+// src/instances-derived-bounds.ts
+var fingerprintScalar = new Float32Array(1);
+var fingerprintBits = new Uint32Array(fingerprintScalar.buffer);
 function fingerprintNumericArray(values) {
   let hash = 2166136261;
-  const scalar = new Float32Array(1);
-  const bits = new Uint32Array(scalar.buffer);
   for (let index = 0; index < values.length; index += 1) {
-    scalar[0] = Number(values[index]);
-    hash = Math.imul(hash ^ (bits[0] ?? 0), 16777619) >>> 0;
+    fingerprintScalar[0] = Number(values[index]);
+    hash = Math.imul(hash ^ (fingerprintBits[0] ?? 0), 16777619) >>> 0;
   }
   return hash >>> 0;
 }
@@ -1448,14 +1687,128 @@ function finiteMatrix(matrix) {
   }
   return true;
 }
-function includeBox(out, candidate) {
-  for (const x of [candidate[0], candidate[3]]) {
-    for (const y of [candidate[1], candidate[4]]) {
-      for (const z of [candidate[2], candidate[5]]) {
-        box3.expandByPoint(out, [x, y, z]);
-      }
-    }
+function multiplyMat4(out, left, right, rightOffset = 0) {
+  for (let column = 0; column < 4; column += 1) {
+    const rightColumn = rightOffset + column * 4;
+    const right0 = Number(right[rightColumn] ?? 0);
+    const right1 = Number(right[rightColumn + 1] ?? 0);
+    const right2 = Number(right[rightColumn + 2] ?? 0);
+    const right3 = Number(right[rightColumn + 3] ?? 0);
+    const outOffset = column * 4;
+    out[outOffset] = Number(left[0] ?? 0) * right0 + Number(left[4] ?? 0) * right1 + Number(left[8] ?? 0) * right2 + Number(left[12] ?? 0) * right3;
+    out[outOffset + 1] = Number(left[1] ?? 0) * right0 + Number(left[5] ?? 0) * right1 + Number(left[9] ?? 0) * right2 + Number(left[13] ?? 0) * right3;
+    out[outOffset + 2] = Number(left[2] ?? 0) * right0 + Number(left[6] ?? 0) * right1 + Number(left[10] ?? 0) * right2 + Number(left[14] ?? 0) * right3;
+    out[outOffset + 3] = Number(left[3] ?? 0) * right0 + Number(left[7] ?? 0) * right1 + Number(left[11] ?? 0) * right2 + Number(left[15] ?? 0) * right3;
+  }
+}
+function finiteMatrixAt(values, offset) {
+  if (values.length - offset < 16) return false;
+  for (let index = 0; index < 16; index += 1) {
+    if (!Number.isFinite(values[offset + index])) return false;
+  }
+  return true;
+}
+function isAffine(matrix) {
+  return matrix[3] === 0 && matrix[7] === 0 && matrix[11] === 0 && matrix[15] === 1;
+}
+function includeBox(out, candidate, initialized) {
+  const minX = candidate[0];
+  const minY = candidate[1];
+  const minZ = candidate[2];
+  const maxX = candidate[3];
+  const maxY = candidate[4];
+  const maxZ = candidate[5];
+  if (!initialized) {
+    out[0] = minX;
+    out[1] = minY;
+    out[2] = minZ;
+    out[3] = maxX;
+    out[4] = maxY;
+    out[5] = maxZ;
+    return true;
   }
+  if (minX < (out[0] ?? Number.POSITIVE_INFINITY)) out[0] = minX;
+  if (minY < (out[1] ?? Number.POSITIVE_INFINITY)) out[1] = minY;
+  if (minZ < (out[2] ?? Number.POSITIVE_INFINITY)) out[2] = minZ;
+  if (maxX > (out[3] ?? Number.NEGATIVE_INFINITY)) out[3] = maxX;
+  if (maxY > (out[4] ?? Number.NEGATIVE_INFINITY)) out[4] = maxY;
+  if (maxZ > (out[5] ?? Number.NEGATIVE_INFINITY)) out[5] = maxZ;
+  return true;
+}
+function transformAabb(out, local, matrix) {
+  const minX = local[0];
+  const minY = local[1];
+  const minZ = local[2];
+  const maxX = local[3];
+  const maxY = local[4];
+  const maxZ = local[5];
+  const centerX = (minX + maxX) * 0.5;
+  const centerY = (minY + maxY) * 0.5;
+  const centerZ = (minZ + maxZ) * 0.5;
+  const extentX = (maxX - minX) * 0.5;
+  const extentY = (maxY - minY) * 0.5;
+  const extentZ = (maxZ - minZ) * 0.5;
+  if (isAffine(matrix)) {
+    const centerWorldX = matrix[0] * centerX + matrix[4] * centerY + matrix[8] * centerZ + matrix[12];
+    const centerWorldY = matrix[1] * centerX + matrix[5] * centerY + matrix[9] * centerZ + matrix[13];
+    const centerWorldZ = matrix[2] * centerX + matrix[6] * centerY + matrix[10] * centerZ + matrix[14];
+    const extentWorldX = Math.abs(matrix[0]) * extentX + Math.abs(matrix[4]) * extentY + Math.abs(matrix[8]) * extentZ;
+    const extentWorldY = Math.abs(matrix[1]) * extentX + Math.abs(matrix[5]) * extentY + Math.abs(matrix[9]) * extentZ;
+    const extentWorldZ = Math.abs(matrix[2]) * extentX + Math.abs(matrix[6]) * extentY + Math.abs(matrix[10]) * extentZ;
+    out[0] = centerWorldX - extentWorldX;
+    out[1] = centerWorldY - extentWorldY;
+    out[2] = centerWorldZ - extentWorldZ;
+    out[3] = centerWorldX + extentWorldX;
+    out[4] = centerWorldY + extentWorldY;
+    out[5] = centerWorldZ + extentWorldZ;
+    return finiteAabb(out);
+  }
+  let minimumW = Number.POSITIVE_INFINITY;
+  let maximumW = Number.NEGATIVE_INFINITY;
+  for (let corner = 0; corner < 8; corner += 1) {
+    const x = (corner & 1) === 0 ? minX : maxX;
+    const y = (corner & 2) === 0 ? minY : maxY;
+    const z = (corner & 4) === 0 ? minZ : maxZ;
+    const w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
+    if (!Number.isFinite(w)) return false;
+    if (w < minimumW) minimumW = w;
+    if (w > maximumW) maximumW = w;
+  }
+  if (minimumW <= 0 && maximumW >= 0) return false;
+  let unionMinX = Number.POSITIVE_INFINITY;
+  let unionMinY = Number.POSITIVE_INFINITY;
+  let unionMinZ = Number.POSITIVE_INFINITY;
+  let unionMaxX = Number.NEGATIVE_INFINITY;
+  let unionMaxY = Number.NEGATIVE_INFINITY;
+  let unionMaxZ = Number.NEGATIVE_INFINITY;
+  for (let corner = 0; corner < 8; corner += 1) {
+    const x = (corner & 1) === 0 ? minX : maxX;
+    const y = (corner & 2) === 0 ? minY : maxY;
+    const z = (corner & 4) === 0 ? minZ : maxZ;
+    const rawX = matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12];
+    const rawY = matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13];
+    const rawZ = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14];
+    const w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
+    const projectedX = rawX / w;
+    const projectedY = rawY / w;
+    const projectedZ = rawZ / w;
+    if (!Number.isFinite(projectedX) || !Number.isFinite(projectedY) || !Number.isFinite(projectedZ)) {
+      return false;
+    }
+    if (projectedX < unionMinX) unionMinX = projectedX;
+    if (projectedY < unionMinY) unionMinY = projectedY;
+    if (projectedZ < unionMinZ) unionMinZ = projectedZ;
+    if (projectedX > unionMaxX) unionMaxX = projectedX;
+    if (projectedY > unionMaxY) unionMaxY = projectedY;
+    if (projectedZ > unionMaxZ) unionMaxZ = projectedZ;
+  }
+  out[0] = unionMinX;
+  out[1] = unionMinY;
+  out[2] = unionMinZ;
+  out[3] = unionMaxX;
+  out[4] = unionMaxY;
+  out[5] = unionMaxZ;
+  return finiteAabb(out);
 }
 function deriveInstancesUnionBounds(input) {
   const { meshAabb, entityWorld, transforms } = input;
@@ -1463,40 +1816,36 @@ function deriveInstancesUnionBounds(input) {
     return void 0;
   }
   if (transforms.length === 0 || transforms.length % 16 !== 0) return void 0;
-  const local = box3.create(
-    meshAabb[0],
-    meshAabb[1],
-    meshAabb[2],
-    meshAabb[3],
-    meshAabb[4],
-    meshAabb[5]
-  );
-  const union = box3.create();
-  const composed = mat4.create();
-  const transformed = box3.create();
+  const local = meshAabb;
+  const union = new Float32Array(6);
+  const composed = new Float32Array(16);
+  const transformed = new Float32Array(6);
+  let initialized = false;
   for (let offset = 0; offset < transforms.length; offset += 16) {
-    const instance = new Float32Array(16);
-    for (let lane = 0; lane < 16; lane += 1) {
-      instance[lane] = transforms[offset + lane];
-    }
-    if (!finiteMatrix(instance)) return void 0;
-    mat4.multiply(composed, entityWorld, instance);
-    box3.transformBox3(transformed, local, composed);
-    if (!finiteAabb(transformed)) return void 0;
-    includeBox(union, transformed);
+    if (!finiteMatrixAt(transforms, offset)) return void 0;
+    multiplyMat4(composed, entityWorld, transforms, offset);
+    if (!finiteMatrix(composed) || !transformAabb(transformed, local, composed)) return void 0;
+    initialized = includeBox(union, transformed, initialized);
   }
-  return new Float32Array(union);
+  return initialized && finiteAabb(union) ? union : void 0;
 }
 var InstanceBoundsCache = class {
   entries = /* @__PURE__ */ new Map();
+  hits = 0;
+  misses = 0;
+  derives = 0;
+  invalidations = 0;
   key(input) {
     return `${input.worldId === void 0 ? "" : `${input.worldId}:`}${input.entityKey}`;
   }
   get(input) {
     const previous = this.entries.get(this.key(input));
     if (previous !== void 0 && previous.meshGeneration === input.meshGeneration && previous.transformGeneration === input.transformGeneration && previous.matrixGeneration === input.matrixGeneration) {
+      this.hits += 1;
       return previous.bounds;
     }
+    this.misses += 1;
+    this.derives += 1;
     const bounds = deriveInstancesUnionBounds(input);
     this.entries.set(this.key(input), {
       ...input.worldId === void 0 ? {} : { worldId: input.worldId },
@@ -1510,11 +1859,22 @@ var InstanceBoundsCache = class {
   }
   invalidate(entityKey, worldId) {
     if (entityKey === void 0) {
+      if (this.entries.size > 0) this.invalidations += this.entries.size;
       this.entries.clear();
     } else {
-      this.entries.delete(this.key({ entityKey, ...worldId === void 0 ? {} : { worldId } }));
+      if (this.entries.delete(this.key({ entityKey, ...worldId === void 0 ? {} : { worldId } }))) {
+        this.invalidations += 1;
+      }
     }
   }
+  inspect() {
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      derives: this.derives,
+      invalidations: this.invalidations
+    };
+  }
 };
 
 // src/points-lines/bounds.ts
@@ -1602,13 +1962,40 @@ function createCookieProjectionMatrixData(count) {
   }
   return data;
 }
+function buildShadowFrusta(lights) {
+  const result = [];
+  const add = (matrix) => {
+    result.push(frustum.fromViewProjection(frustum.create(), matrix));
+  };
+  for (const matrix of lights.lightViewProj?.slice(0, lights.cascadeCount) ?? []) add(matrix);
+  for (const snapshot of lights.pointShadow) {
+    if (snapshot.shadowAtlasLayer < 0) continue;
+    for (let face = 0; face < 6; face += 1)
+      add(snapshot.shadowMatrices.subarray(face * 16, (face + 1) * 16));
+  }
+  for (const snapshot of lights.spot) {
+    if (snapshot.shadowAtlasTile >= 0 && snapshot.lightViewProj !== void 0)
+      add(snapshot.lightViewProj);
+  }
+  return result;
+}
 
 // src/render-system-extract-tail.ts
+function skinPaletteIdentity(world, entity) {
+  return `skin:${world.identity}:${entity}`;
+}
 function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCachesByWorld, options = {}) {
   const cameraOwner = typeof owner === "number" ? owner : owner.cameraOwner;
   const resourceOwner = typeof owner === "number" ? owner : owner.resourceOwner;
+  const cameraEntityKey = typeof owner === "number" ? void 0 : owner.cameraEntityKey;
+  const renderableRequest = options.renderables ?? "full";
+  const renderableMode = typeof renderableRequest === "object" ? "full" : renderableRequest;
+  const partialEntitiesByWorld = typeof renderableRequest === "object" ? renderableRequest.entitiesByWorld : void 0;
+  const retainHidden = options.retainHidden ?? typeof renderableRequest === "object";
   const skinPaletteAllocator = pipelineState?.skinPaletteAllocator ?? null;
-  if (skinPaletteAllocator !== null) {
+  const reconcileSkinFrame = renderableRequest === "full";
+  if (skinPaletteAllocator !== null && reconcileSkinFrame) {
+    skinPaletteAllocator.beginFrame();
     skinPaletteAllocator.resetForFrame();
   }
   const failedWorlds = /* @__PURE__ */ new Set();
@@ -1626,6 +2013,13 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
     const world = worlds[wi];
     if (world === void 0 || failedWorlds.has(world)) continue;
     try {
+      if (skinPaletteAllocator !== null && partialEntitiesByWorld !== void 0) {
+        for (const entityKey of partialEntitiesByWorld[wi] ?? []) {
+          if (!world.hasComponent(entityKey, Skin)) {
+            skinPaletteAllocator.releasePersistentSlice(skinPaletteIdentity(world, entityKey));
+          }
+        }
+      }
       const isCameraOwner = wi === cameraOwner;
       const cameraOwnerFrame2 = framesByWorld.get(cameraOwner);
       const prepared = prepareExtractContext(world, {
@@ -1641,18 +2035,20 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
         },
         ...options.materialContext === void 0 ? {} : { materialContext: options.materialContext },
         cull: options.cull === "none" ? "none" : isCameraOwner ? "self" : "external",
-        renderables: options.renderables ?? "full",
-        ...options.renderableEntitiesByWorld?.[wi] === void 0 ? {} : { renderableEntities: options.renderableEntitiesByWorld[wi] },
-        retainHidden: options.retainHidden ?? false,
+        renderables: renderableMode,
+        ...isCameraOwner && cameraEntityKey !== void 0 ? { cameraEntityKey } : {},
+        ...partialEntitiesByWorld?.[wi] === void 0 ? {} : { renderableEntities: partialEntitiesByWorld[wi] },
+        retainHidden,
+        worldId: wi,
         ...options.getMaterialShaderArtifact === void 0 ? {} : { getMaterialShaderArtifact: options.getMaterialShaderArtifact },
         ...options.instanceCollections === void 0 ? {} : { instanceCollections: options.instanceCollections },
         ...cameraOwnerFrame2 === void 0 ? {} : { cullCameras: cameraOwnerFrame2.cameras }
       });
       const frame = extractFrame(world, prepared);
       framesByWorld.set(wi, frame);
-    } catch (err6) {
+    } catch (err8) {
       try {
-        createWorldInternalView(world)._routeError(err6, {
+        createWorldInternalView(world)._routeError(err8, {
           severity: Severity.Error,
           systemName: `RenderSystem.extractFrames(world[${wi}])`
         });
@@ -1660,6 +2056,9 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
       }
     }
   }
+  if (skinPaletteAllocator !== null && reconcileSkinFrame) {
+    skinPaletteAllocator.endFrame();
+  }
   for (let wi = 0; wi < worlds.length; wi++) {
     const frame = framesByWorld.get(wi);
     if (frame === void 0) continue;
@@ -1668,6 +2067,9 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
   }
   const renderables = [];
   const dispatchEntries = [];
+  const shadowCasterEntityKeys = /* @__PURE__ */ new Set();
+  const shadowCasterDrawKeys = /* @__PURE__ */ new Set();
+  const shadowCasterMembership = /* @__PURE__ */ new Map();
   const visibilitySnapshots = [];
   const featureVisibilitySnapshots = [];
   const hiddenEntityReports = [];
@@ -1694,6 +2096,18 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
     for (const d of f.dispatch) {
       dispatchEntries.push({ ...d, renderableIndex: (d.renderableIndex ?? 0) + base });
     }
+    for (const key of f.shadowCasterEntityKeys) shadowCasterEntityKeys.add(key);
+    for (const key of f.shadowCasterDrawKeys) shadowCasterDrawKeys.add(key);
+    for (const membership of f.shadowCasterMembership ?? []) {
+      const rebased = { ...membership, renderableIndex: membership.renderableIndex + base };
+      const key = gpuDrivenShadowDrawKey(
+        rebased.worldEntity,
+        rebased.materialHandle,
+        rebased.drawItemIndex,
+        rebased.passIndex
+      );
+      shadowCasterMembership.set(key, rebased);
+    }
   }
   dispatchEntries.sort((a, b) => (a.queue ?? 0) - (b.queue ?? 0));
   const point = [];
@@ -1713,11 +2127,14 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
   const pointShadow = [];
   let directionalCsmConfig;
   let directionalCsmDirection;
-  for (const f of succeededFrames) {
-    for (const p of f.lights.point) point.push(p);
-    for (const s of f.lights.spot) spot.push(s);
+  for (let fi = 0; fi < succeededFrames.length; fi += 1) {
+    const f = succeededFrames[fi];
+    const wId = succeededIndices[fi] ?? 0;
+    if (f === void 0) continue;
+    for (const p of f.lights.point) point.push({ ...p, worldId: wId });
+    for (const s of f.lights.spot) spot.push({ ...s, worldId: wId });
     for (const r of f.lights.rect) rect.push(r);
-    for (const ps of f.lights.pointShadow) pointShadow.push(ps);
+    for (const ps of f.lights.pointShadow) pointShadow.push({ ...ps, worldId: wId });
     if (directional === void 0 && f.lights.directional !== void 0) {
       directional = f.lights.directional;
       lightViewProj = f.lights.lightViewProj;
@@ -1740,8 +2157,8 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
     if (succeededIndices[fi] === cameraOwner) cameraOwnerFrame = succeededFrames[fi];
     if (succeededIndices[fi] === resourceOwner) resourceOwnerFrame = succeededFrames[fi];
   }
-  const cameras = cameraOwnerFrame !== void 0 ? [...cameraOwnerFrame.cameras] : [];
-  const auxiliaryCameras = cameraOwnerFrame !== void 0 ? [...cameraOwnerFrame.auxiliaryCameras] : [];
+  const cameras = cameraOwnerFrame?.cameras.map((camera) => ({ ...camera, worldId: cameraOwner })) ?? [];
+  const auxiliaryCameras = cameraOwnerFrame?.auxiliaryCameras.map((camera) => ({ ...camera, worldId: cameraOwner })) ?? [];
   const cubeCameras = cameraOwnerFrame !== void 0 ? [...cameraOwnerFrame.cubeCameras] : [];
   const mergeCam = cameras[0];
   if (directionalCsmConfig !== void 0 && directionalCsmDirection !== void 0) {
@@ -1798,7 +2215,10 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
   const fog = resourceOwnerFrame?.fog;
   const fogFailure = resourceOwnerFrame?.fogFailure;
   const environment = resourceOwnerFrame?.environment;
-  const lightProbes = succeededFrames.flatMap((frame) => frame.lightProbes ?? []);
+  const lightProbes = succeededFrames.flatMap((frame, index) => {
+    const worldId = succeededIndices[index] ?? 0;
+    return (frame.lightProbes ?? []).map((probe) => ({ ...probe, worldId }));
+  });
   const postProcessParams = new Map(resourceOwnerFrame?.postProcessParams);
   const OUTPUT_TRANSFORM_PARAM_KEY = STANDARD_OUTPUT_TRANSFORM_FEATURE_ID;
   const cameraTonemapParam = cameraOwnerFrame?.postProcessParams.get(OUTPUT_TRANSFORM_PARAM_KEY);
@@ -1814,28 +2234,28 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
   const visibilityStats = {
     explicitlyHidden: succeededFrames.reduce((s, f) => s + f.visibilityStats.explicitlyHidden, 0)
   };
+  const materialTextureSources = {
+    sourceFieldsVisited: 0,
+    numericSharedRefProbes: 0,
+    sourceCacheHits: 0,
+    sourceCacheMisses: 0,
+    producerRoutes: {}
+  };
+  for (const frame of succeededFrames) {
+    const stats = frame.materialTextureSources;
+    if (stats === void 0) continue;
+    materialTextureSources.sourceFieldsVisited += stats.sourceFieldsVisited;
+    materialTextureSources.numericSharedRefProbes += stats.numericSharedRefProbes;
+    materialTextureSources.sourceCacheHits += stats.sourceCacheHits;
+    materialTextureSources.sourceCacheMisses += stats.sourceCacheMisses;
+    for (const [route, count] of Object.entries(stats.producerRoutes)) {
+      materialTextureSources.producerRoutes[route] = (materialTextureSources.producerRoutes[route] ?? 0) + count;
+    }
+  }
   const reflectionProbes = succeededFrames.flatMap((f, index) => {
     const worldId = succeededIndices[index] ?? 0;
     return (f.reflectionProbes ?? []).map((probe) => ({ ...probe, worldId }));
   });
-  if (options.renderables !== "none" && options.renderableEntitiesByWorld === void 0) {
-    options.instanceCollections?.retain(
-      new Set(
-        renderables.flatMap(
-          (row) => row.instances?.collectionId === void 0 ? [] : [row.instances.collectionId]
-        )
-      )
-    );
-    if (skinPaletteAllocator !== null && typeof skinPaletteAllocator.retainSliceKeys === "function") {
-      skinPaletteAllocator.retainSliceKeys(
-        new Set(
-          renderables.flatMap(
-            (row) => row.skin === void 0 ? [] : [`${worlds[row.worldId]?.identity ?? row.worldId}:${row.entityKey}`]
-          )
-        )
-      );
-    }
-  }
   return {
     cameras,
     auxiliaryCameras,
@@ -1845,6 +2265,9 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
     ...volumetricFog === void 0 ? {} : { volumetricFog: { ...volumetricFog, worldId: resourceOwner } },
     renderables,
     dispatch: dispatchEntries,
+    shadowCasterEntityKeys,
+    shadowCasterDrawKeys,
+    ...shadowCasterMembership.size === 0 ? {} : { shadowCasterMembership: [...shadowCasterMembership.values()] },
     skylight,
     skylightCount,
     lightProbes,
@@ -1856,6 +2279,7 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
     environmentReady: resourceOwnerFrame !== void 0 && environment !== void 0,
     frustumStats,
     visibilityStats,
+    materialTextureSources,
     postProcessParams,
     visibilitySnapshots,
     featureVisibilitySnapshots,
@@ -1898,6 +2322,7 @@ function morphSnapshotFor(mesh, weights) {
     if (!Number.isFinite(weight)) return void 0;
     copied[index] = weight;
   }
+  if (copied.every((weight) => weight === 0)) return void 0;
   return { weights: copied, targetCount: targets.length };
 }
 function extractFrame(world, context) {
@@ -1916,10 +2341,18 @@ function extractFrame(world, context) {
   const fogFailure = fogState(world).failure;
   const visibility = context.visibility.hasAnyHiddenIntent ? context.visibility : void 0;
   const skinPaletteAllocator = pipelineState?.skinPaletteAllocator ?? null;
+  const materialTextureSourceStats = {
+    sourceFieldsVisited: 0,
+    numericSharedRefProbes: 0,
+    sourceCacheHits: 0,
+    sourceCacheMisses: 0,
+    producerRoutes: {}
+  };
+  const materialTextureSourceCache = /* @__PURE__ */ new Map();
   const directionalLightQuery = world.query({ read: [DirectionalLight] }).unwrap();
   const worldInternal = createWorldInternalView(world);
   let volumetricFog = extractVolumeSnapshot(world, assets, worldInternal);
-  const cameraRoles = selectCameraRoles(world);
+  const cameraRoles = selectCameraRoles(world, context.cameraEntityKey);
   const cameras = [...cameraRoles.display];
   const auxiliaryCameras = cameraRoles.auxiliary;
   const cubeCameras = collectCubeCameraSnapshots(world);
@@ -1996,6 +2429,7 @@ function extractFrame(world, context) {
     pointSnapshots.push({
       kind: "point",
       entity: entityId,
+      worldId: context.worldId,
       position,
       color: vec3.create(
         (p.color[0] ?? 1) * intensity,
@@ -2129,6 +2563,7 @@ function extractFrame(world, context) {
     spotSnapshots.push({
       kind: "spot",
       entity: row.entity,
+      worldId: context.worldId,
       // D-6: position reflects world transform; direction stays sourced
       // from SpotLight.direction (NOT rotated by the parent).
       position,
@@ -2340,10 +2775,13 @@ function extractFrame(world, context) {
       }
       pointShadowSnapshots.push({
         entity: row.entity,
+        worldId: context.worldId,
         position: lightPos,
         mapSize,
         nearPlane,
         farPlane,
+        depthBias: ps.depthBias,
+        normalBias: ps.normalBias,
         shadowAtlasLayer: layer,
         shadowMatrices: packed
       });
@@ -2386,6 +2824,7 @@ function extractFrame(world, context) {
     directionalCsmConfig,
     directionalCsmDirection
   };
+  const shadowFrusta = cullMode === "none" ? [] : buildShadowFrusta(lights);
   const skylightQuery = world.query({ read: [Skylight] }).unwrap();
   let skylight;
   let skylightCount = 0;
@@ -2432,6 +2871,7 @@ function extractFrame(world, context) {
     const transform = row.get(GlobalTransform);
     lightProbes.push({
       identity: String(row.entity),
+      worldId: context.worldId,
       position: [transform.world[12] ?? 0, transform.world[13] ?? 0, transform.world[14] ?? 0],
       radius: probe.radius,
       irradiance: new Float32Array(probe.irradiance),
@@ -2494,19 +2934,21 @@ function extractFrame(world, context) {
     directionalDirection[1] ?? 0,
     directionalDirection[2] ?? 0
   );
-  const sun = directional === void 0 || directionalLength <= 1e-6 ? [] : [
+  const sunIntensity = directional?.intensity ?? 0;
+  const sunColor = sunIntensity > 0 && directional !== void 0 ? [
+    (directional.color[0] ?? 0) / sunIntensity,
+    (directional.color[1] ?? 0) / sunIntensity,
+    (directional.color[2] ?? 0) / sunIntensity
+  ] : [0, 0, 0];
+  const sun = directional === void 0 || directional.entity === void 0 || directionalLength <= 1e-6 ? [] : [
     {
-      entityKey: 0,
+      entityKey: directional.entity,
       direction: [
         -(directionalDirection?.[0] ?? 0) / directionalLength,
         -(directionalDirection?.[1] ?? 0) / directionalLength,
         -(directionalDirection?.[2] ?? 0) / directionalLength
       ],
-      color: [
-        directional.color[0] ?? 0,
-        directional.color[1] ?? 0,
-        directional.color[2] ?? 0
-      ],
+      color: sunColor,
       intensity: directional.intensity
     }
   ];
@@ -2563,7 +3005,9 @@ function extractFrame(world, context) {
   let frustumTotal = 0;
   const explicitlyHidden = /* @__PURE__ */ new Set();
   let dispatch = [];
+  const shadowMembershipEntries = [];
   const materialSnapshotCache = /* @__PURE__ */ new Map();
+  const instanceSnapshotCache = /* @__PURE__ */ new Map();
   const skinnedMaterialSnapshotCache = /* @__PURE__ */ new Map();
   const meshRendererQuery = context.renderables === "none" ? [] : world.query({
     read: [MeshRenderer],
@@ -2606,7 +3050,8 @@ function extractFrame(world, context) {
     }
     const hasTransform = row.has(Transform);
     const meshFilter = row.get(MeshFilter);
-    const hasInstances = row.has(Instances);
+    const instancesData = row.get(Instances);
+    const hasInstances = instancesData !== void 0;
     const skin = row.get(Skin);
     const morphWeightsView = worldInternal._getArrayView(row.entity, MorphWeights, "weights");
     const hasMeshFilter = meshFilter !== void 0;
@@ -2641,9 +3086,7 @@ function extractFrame(world, context) {
         () => "renderer-override"
       );
       let materialBindingDiagnostics = [];
-      let gpuDrivenSubmeshes = [];
-      let gpuDrivenIndexed = false;
-      let gpuDrivenGeometry;
+      let gpuDrivenMesh;
       const fAssetHandleVal = fAssetHandle;
       if (fAssetHandleVal !== void 0 && fAssetHandleVal !== 0 && assets !== void 0 && assets !== null) {
         const meshHandle = toShared(fAssetHandleVal);
@@ -2651,19 +3094,7 @@ function extractFrame(world, context) {
         if (meshRes.ok && meshRes.value.kind === "mesh") {
           const meshAsset = meshRes.value;
           const guid = meshRes.value.guid ?? "<no-guid>";
-          gpuDrivenSubmeshes = meshAsset.submeshes;
-          gpuDrivenIndexed = meshAsset.indices !== void 0;
-          const layoutProjection = deriveVertexLayoutProjection(meshAsset.attributes);
-          gpuDrivenGeometry = {
-            identity: `${guid}:${layoutProjection.digest}`,
-            vertexInputs: layoutProjection.attributes.map((attribute) => ({
-              semantic: attribute.key,
-              location: attribute.shaderLocation,
-              format: attribute.format
-            })),
-            topology: meshAsset.submeshes[0]?.topology ?? "triangle-list",
-            indexed: gpuDrivenIndexed
-          };
+          gpuDrivenMesh = meshAsset;
           if (!Array.isArray(meshAsset.materialSlots) && world.get(entity, GlyphText).ok) {
             ensureGlyphMeshMaterialSlots(world, meshHandle);
           }
@@ -2830,28 +3261,28 @@ function extractFrame(world, context) {
           } else {
             const resolvedResult = walkMaterialPassesOverSharedRefs(world, tagged, assets);
             if (!resolvedResult.ok) {
-              const err6 = resolvedResult.error;
-              switch (err6.code) {
+              const err8 = resolvedResult.error;
+              switch (err8.code) {
                 case "material-parent-not-found":
                 case "material-no-effective-pass":
                 case "material-value-unknown":
                 case "material-value-type-mismatch":
                 case "material-contract-program-mismatch":
-                  worldInternal._routeError(err6, {
+                  worldInternal._routeError(err8, {
                     severity: Severity.Error,
-                    systemName: `RenderSystem.extract (${err6.code})`
+                    systemName: `RenderSystem.extract (${err8.code})`
                   });
                   break;
                 case "material-circular-inheritance":
-                  worldInternal._routeError(err6, {
+                  worldInternal._routeError(err8, {
                     severity: Severity.Error,
                     systemName: "RenderSystem.extract (material-circular-inheritance)"
                   });
                   break;
                 default:
-                  worldInternal._routeError(err6, {
+                  worldInternal._routeError(err8, {
                     severity: Severity.Error,
-                    systemName: `RenderSystem.extract (_materialWalk: ${err6.code})`
+                    systemName: `RenderSystem.extract (_materialWalk: ${err8.code})`
                   });
               }
               continue;
@@ -2867,6 +3298,11 @@ function extractFrame(world, context) {
               assets,
               materialContext
             );
+            const materialSceneIndexProgramKeys = materialSceneIndexProgramKeysForMaterial(
+              asset,
+              assets,
+              materialContext
+            );
             const authoredFirstPassShader = runtimeMaterialShaderIdForMaterial(
               allPasses,
               void 0
@@ -2983,6 +3419,16 @@ function extractFrame(world, context) {
               firstPassShader,
               materialParamSchema.length > 0 ? derive(materialParamSchema).textureFieldNames : firstPassShader !== void 0 && assets !== null && assets !== void 0 ? assets.materialShaderTextureFieldNames(firstPassShader) : void 0
             ) ?? BUILTIN_USER_REGION_TEXTURE_FIELDS;
+            const authoredTextureFields = collectAuthoredMaterialTextureFields(
+              resolved.values,
+              firstPassShader,
+              materialParamSchema.length > 0 ? materialParamSchema : void 0,
+              assets
+            );
+            const authoredSamplerFields = collectAuthoredMaterialSamplerFields(
+              resolved.values,
+              authoredTextureFields
+            );
             const textureHandles = /* @__PURE__ */ new Map();
             const videoTextureFields = /* @__PURE__ */ new Map();
             for (const field of userRegionFields) {
@@ -3010,7 +3456,15 @@ function extractFrame(world, context) {
               pv.occlusionTexture
             );
             const textureCoordinates = collectMaterialTextureCoordinates(pv);
-            const textureSources = collectMaterialTextureSources(pv, world);
+            const textureSources = collectMaterialTextureSources(
+              pv,
+              world,
+              materialTextureSourceFields(
+                materialParamSchema.length > 0 ? materialParamSchema : void 0
+              ),
+              materialTextureSourceStats,
+              materialTextureSourceCache
+            );
             const emissivePv = pv.emissive;
             const firstPassTransparent = allPasses[0]?.renderState?.blend !== void 0;
             if (isSprite) {
@@ -3064,12 +3518,20 @@ function extractFrame(world, context) {
               normalScale: normalScalePv,
               materialShaderId: firstPassShader,
               materialProgramKeys,
+              materialSceneIndexProgramKeys,
               materialHandle: handleRaw,
               renderState: pipelineRenderState(allPasses[0]?.renderState),
               paramSnapshot: paramSnap,
               ...materialParamSchema.length > 0 && { materialParamSchema },
+              standardTextureMask: materialStandardTextureMask(
+                resolved.parameters,
+                firstPassShader,
+                pv
+              ),
               ...textureCoordinates.size > 0 && { textureCoordinates },
+              ...authoredTextureFields === void 0 ? {} : { authoredTextureFields },
               ...samplerHandles.size > 0 && { samplerHandles },
+              ...authoredSamplerFields === void 0 ? {} : { authoredSamplerFields },
               ...textureHandles.size > 0 && { textureHandles },
               ...textureSources.size > 0 && { textureSources },
               ...videoTextureFields.size > 0 && { videoTextureFields },
@@ -3155,6 +3617,12 @@ function extractFrame(world, context) {
       }
       if (isRenderable) {
         let skinSlice;
+        const skinIdentity = hasSkin ? skinPaletteIdentity(world, entity) : void 0;
+        const releaseSkinIdentity = () => {
+          if (skinIdentity !== void 0) {
+            skinPaletteAllocator?.releasePersistentSlice(skinIdentity);
+          }
+        };
         if (hasSkin) {
           const skeletonHandleRaw = skinSkeletonView;
           if (skeletonHandleRaw !== void 0 && skeletonHandleRaw !== 0 && assets !== void 0 && assets !== null) {
@@ -3163,6 +3631,7 @@ function extractFrame(world, context) {
                 severity: Severity.Error,
                 systemName: "RenderSystem.extract (skin-instances-coexist)"
               });
+              releaseSkinIdentity();
               continue;
             }
             const skeletonHandle = toShared(skeletonHandleRaw);
@@ -3172,11 +3641,15 @@ function extractFrame(world, context) {
                 severity: Severity.Error,
                 systemName: "RenderSystem.extract (skeleton-resolve-failed)"
               });
+              releaseSkinIdentity();
               continue;
             }
             const skeleton = skeletonRes.value;
             const skinJoints = skin?.joints;
-            if (skinJoints === void 0) continue;
+            if (skinJoints === void 0) {
+              releaseSkinIdentity();
+              continue;
+            }
             const jointsLength = skinJoints.length;
             if (jointsLength !== skeleton.jointCount) {
               worldInternal._routeError(
@@ -3186,6 +3659,7 @@ function extractFrame(world, context) {
                   systemName: "RenderSystem.extract (joint-count-mismatch)"
                 }
               );
+              releaseSkinIdentity();
               continue;
             }
             const jointWorlds = new Array(skeleton.jointCount);
@@ -3207,6 +3681,7 @@ function extractFrame(world, context) {
                 severity: Severity.Error,
                 systemName: "RenderSystem.extract (joint-entity-dangling)"
               });
+              releaseSkinIdentity();
               continue;
             }
             const ibmFlat = skeleton.inverseBindMatrices;
@@ -3215,25 +3690,33 @@ function extractFrame(world, context) {
               ibms[jIdx] = ibmFlat.subarray(jIdx * 16, jIdx * 16 + 16);
             }
             if (skinPaletteAllocator !== null) {
-              const slice = typeof skinPaletteAllocator.allocateSliceFor === "function" ? skinPaletteAllocator.allocateSliceFor(
-                `${world.identity}:${entity}`,
-                skeleton.jointCount
-              ) : skinPaletteAllocator.allocateSlice(skeleton.jointCount);
-              skinPaletteAllocator.writeJointPalette(slice, ibms, jointWorlds);
-              skinSlice = {
-                jointCount: slice.jointCount,
-                byteOffset: slice.byteOffset,
-                buffer: slice.buffer
-              };
+              const identity = skinPaletteIdentity(world, entity);
+              const generation = skeletonHandleRaw >>> 0 ^ skeleton.jointCount;
+              const bounds = hasFiniteOrderedLocalAabb(skeleton.bounds) ? new Float32Array(skeleton.bounds) : void 0;
+              skinPaletteAllocator.observePersistentJoints(identity, ibms, jointWorlds);
+              const receipt = skinPaletteAllocator.allocatePersistentSlice({
+                identity,
+                generation: generation >>> 0,
+                jointCount: skeleton.jointCount,
+                ...bounds === void 0 ? {} : { bounds }
+              });
+              skinPaletteAllocator.writePersistentJointPalette(receipt, ibms, jointWorlds);
+              skinSlice = receipt;
             }
           }
         }
-        if (materialSnap.materialShaderId === "forgeax::pbr-skin" && skinSlice === void 0) {
-          pendingDispatch.length = 0;
-          continue;
+        if (skinSlice === void 0 && hasSkin) {
+          releaseSkinIdentity();
+          if (materialSnap.materialShaderId === "forgeax::pbr-skin") {
+            pendingDispatch.length = 0;
+            continue;
+          }
         }
         const worldView = worldInternal._getArrayView(entity, GlobalTransform, "world");
-        if (worldView === void 0) continue;
+        if (worldView === void 0) {
+          releaseSkinIdentity();
+          continue;
+        }
         const worldMat = new Float32Array(worldView);
         const transformSnap = { world: worldMat };
         const materialsArr = [materialSnap];
@@ -3252,7 +3735,9 @@ function extractFrame(world, context) {
                 context.materialContext === void 0 ? void 0 : {
                   ...context.materialContext,
                   geometry: hasSkin ? "skinned" : context.materialContext.geometry
-                }
+                },
+                materialTextureSourceStats,
+                materialTextureSourceCache
               )
             );
           }
@@ -3344,7 +3829,7 @@ function extractFrame(world, context) {
             lods = meshAsset.lods;
             lodHysteresis = meshAsset.lodHysteresis;
             morph = morphSnapshotFor(meshAsset, morphWeightsView);
-            const meshAabb = meshAsset.aabb;
+            const meshAabb = skinSlice?.bounds ?? meshAsset.aabb;
             if (morph === void 0 && hasFiniteOrderedLocalAabb(meshAabb)) {
               localAabb = new Float32Array(meshAabb);
             }
@@ -3356,7 +3841,7 @@ function extractFrame(world, context) {
         })() : lines === void 0 ? void 0 : { kind: "lines", widthPx: lines.widthPx };
         const cullingLocalAabb = expandPointsLinesBounds(localAabb ?? [], pointsLinesStyle);
         const pointsLines = pointsLinesComponent === void 0 ? void 0 : {
-          worldId: 0,
+          worldId: context.worldId,
           entityKey: entity,
           component: pointsLinesComponent,
           meshHandle: assetHandleRaw,
@@ -3373,27 +3858,44 @@ function extractFrame(world, context) {
         };
         let instancesSnap;
         if (hasInstances) {
-          const transforms = worldInternal._getArrayView(entity, Instances, "transforms") ?? new Float32Array();
-          if (transforms.length % 16 !== 0) {
-            worldInternal._routeError(
-              new InstanceTransformsStrideMismatchError(transforms.length),
-              {
-                severity: Severity.Error,
-                systemName: "RenderSystem.extract (Instances stride)"
-              }
+          const collectionId = instancesData?.collectionId;
+          let collectionResult = collectionId !== void 0 ? instanceSnapshotCache.get(collectionId) : void 0;
+          if (collectionResult === void 0) {
+            collectionResult = collectionId !== void 0 && collectionId > 0 && instanceCollections !== void 0 ? instanceCollections.snapshot(collectionId) : err(
+              new InstanceCollectionError(
+                "instance-collection-invalid",
+                "Instances.collectionId references a live renderer-owned collection",
+                "create the collection through renderer.instances before attaching Instances",
+                {
+                  operation: "inspect",
+                  expected: "a positive collectionId with a live renderer owner",
+                  actual: Number(collectionId ?? 0),
+                  ...collectionId === void 0 ? {} : { collectionId }
+                }
+              )
             );
+            if (collectionId !== void 0)
+              instanceSnapshotCache.set(collectionId, collectionResult);
+          }
+          if (collectionResult === void 0) continue;
+          if (!collectionResult.ok) {
+            worldInternal._routeError(collectionResult.error, {
+              severity: Severity.Error,
+              systemName: "RenderSystem.extract (Instances collection)"
+            });
             continue;
           }
-          const projected = instanceCollections?.project(world, entity, transforms);
           instancesSnap = {
-            transforms: projected?.transforms ?? new Float32Array(transforms),
-            instanceCount: transforms.length / 16,
+            transforms: collectionResult.value.transforms,
+            instanceCount: collectionResult.value.count,
+            collectionId: collectionResult.value.collectionId,
+            revision: collectionResult.value.revision,
+            capacity: collectionResult.value.capacity,
+            dirtyRanges: collectionResult.value.dirtyRanges,
             cacheKey: entity,
-            archVersion: projected === void 0 ? fingerprintNumericArray(transforms) : 0,
-            ...projected === void 0 ? {} : {
-              collectionId: projected.collectionId,
-              revision: projected.revision
-            }
+            // Explicit collection revisions supersede ECS archetype content
+            // hashes; retain zero as the legacy sprite-only field value.
+            archVersion: 0
           };
         }
         const baseRenderable = {
@@ -3406,7 +3908,7 @@ function extractFrame(world, context) {
           materials: materialsArr,
           materialBindingSources,
           materialBindingDiagnostics,
-          worldId: 0,
+          worldId: context.worldId,
           entityKey: entity,
           ...authorVisible ? {} : { authorVisible: false },
           ...skinSlice !== void 0 ? { skin: skinSlice } : {},
@@ -3417,32 +3919,25 @@ function extractFrame(world, context) {
           ...pointsLines !== void 0 ? { pointsLines } : {}
         };
         const gpuDrivenDraws = buildGpuDrivenDraws({
-          submeshes: gpuDrivenSubmeshes,
-          indexed: gpuDrivenIndexed,
+          mesh: gpuDrivenMesh,
           materials: materialsArr,
           fallbackMaterial: materialSnap,
-          ...gpuDrivenGeometry === void 0 || getMaterialShaderArtifact === void 0 ? {} : {
-            prepare(draw, drawMaterial) {
-              const materialShaderId = drawMaterial.materialShaderId;
-              if (materialShaderId === void 0) return void 0;
-              const artifact = getMaterialShaderArtifact(materialShaderId);
-              if (artifact?.receipt === void 0) return void 0;
-              const geometry = {
-                ...gpuDrivenGeometry,
-                topology: draw.topology,
-                indexed: draw.kind === "indexed"
-              };
-              const result = resolvePreparedGpuDrivenDraw({
-                snapshot: { ...baseRenderable, material: drawMaterial },
-                artifact,
-                geometry,
-                generation: artifact.receipt.generation,
-                draw
-              });
-              return result.ok ? result.value : void 0;
-            }
+          baseSnapshot: baseRenderable,
+          ...getMaterialShaderArtifact === void 0 ? {} : { getMaterialShaderArtifact },
+          ...lods === void 0 ? {} : {
+            lodMeshes: lods.map((lod) => {
+              const lower = assets?.lookup(lod.mesh);
+              return lower?.kind === "mesh" ? lower : void 0;
+            })
           }
         });
+        for (const draw of gpuDrivenDraws) {
+          if (draw.preparationError === void 0) continue;
+          worldInternal._routeError(draw.preparationError, {
+            severity: Severity.Error,
+            systemName: `RenderSystem.extract (gpu-driven-preparation:${draw.preparationError.code})`
+          });
+        }
         const renderable = morph === void 0 && gpuDrivenDraws.length > 0 ? { ...baseRenderable, gpuDrivenDraws } : baseRenderable;
         if (localAabb !== void 0) {
           const derivedInstancesBounds = instancesSnap === void 0 || instancesSnap.instanceCount === 0 ? void 0 : deriveInstancesUnionBounds({
@@ -3477,16 +3972,96 @@ function extractFrame(world, context) {
             }
             if (!visible) {
               frustumCulled += 1;
+              const shadowVisible = shadowFrusta.length > 0 && pendingDispatch.some((entry) => entry.tags.LightMode === "ShadowCaster") && shadowFrusta.some(
+                (lightPlanes) => frustum.intersectsBox(lightPlanes, worldAabb)
+              );
+              if (!shadowVisible) continue;
+              for (let i = pendingDispatch.length - 1; i >= 0; i -= 1) {
+                if (pendingDispatch[i]?.tags.LightMode !== "ShadowCaster") {
+                  pendingDispatch.splice(i, 1);
+                }
+              }
+            }
+          }
+        }
+        const localShadowMembershipEntries = [];
+        if (gpuDrivenMesh !== void 0) {
+          const worldEntity = worldEntityKey(context.worldId, entity);
+          for (const [drawItemIndex, submesh] of gpuDrivenMesh.submeshes.entries()) {
+            if (submesh.topology !== "triangle-list" && submesh.topology !== "triangle-strip") {
               continue;
             }
+            const material = materialsArr[submesh.materialSlot] ?? materialSnap;
+            const materialHandle = material.materialHandle ?? -1;
+            const shadowEntries = pendingDispatch.filter(
+              (entry) => entry.tags.LightMode === "ShadowCaster" && entry.materialHandle === materialHandle
+            );
+            const draw = renderable.gpuDrivenDraws?.find(
+              (candidate, compactIndex) => gpuDrivenSourceDrawItemIndex(candidate, compactIndex) === drawItemIndex
+            );
+            const cpuReason = shadowCasterCpuReason(
+              material,
+              draw,
+              shadowEntries,
+              morph,
+              skinSlice
+            );
+            for (const entry of shadowEntries) {
+              const membership = {
+                worldEntity,
+                renderableIndex: renderables.length,
+                drawItemIndex,
+                materialHandle,
+                passIndex: entry.passIndex,
+                ...entry.materialShaderId === void 0 ? {} : { materialShaderId: entry.materialShaderId },
+                ...entry.vertexEntry === void 0 ? {} : { vertexEntry: entry.vertexEntry },
+                ...entry.fragmentEntry === void 0 ? {} : { fragmentEntry: entry.fragmentEntry },
+                ...entry.renderState === void 0 ? {} : { renderState: entry.renderState },
+                ...cpuReason === void 0 ? {} : { cpuReason },
+                gpuDrivenEligible: cpuReason === void 0
+              };
+              shadowMembershipEntries.push(membership);
+              localShadowMembershipEntries.push(membership);
+            }
           }
         }
+        const shadowCasterPasses = localShadowMembershipEntries.map((membership) => ({
+          drawItemIndex: membership.drawItemIndex,
+          materialHandle: membership.materialHandle,
+          passIndex: membership.passIndex,
+          ...membership.materialShaderId === void 0 ? {} : { materialShaderId: membership.materialShaderId },
+          ...membership.renderState === void 0 ? {} : { renderState: membership.renderState },
+          ...membership.cpuReason === void 0 ? {} : { cpuReason: membership.cpuReason }
+        }));
+        const renderableWithShadowPasses = shadowCasterPasses.length === 0 ? renderable : { ...renderable, shadowCasterPasses };
         flushPendingDispatch(pendingDispatch);
-        renderables.push(renderable);
+        renderables.push(renderableWithShadowPasses);
       }
     }
   }
   dispatch = sortDispatchByQueue(dispatch);
+  const shadowCasterEntityKeys = /* @__PURE__ */ new Set();
+  const shadowCasterDrawKeys = /* @__PURE__ */ new Set();
+  const shadowCasterMembership = /* @__PURE__ */ new Map();
+  for (const entry of dispatch) {
+    if (entry.tags.LightMode !== "ShadowCaster") continue;
+    const renderable = renderables[entry.renderableIndex];
+    if (renderable !== void 0) {
+      const worldEntity = worldEntityKey(renderable.worldId, renderable.entityKey);
+      shadowCasterEntityKeys.add(worldEntity);
+    }
+  }
+  for (const membership of shadowMembershipEntries) {
+    const key = gpuDrivenShadowDrawKey(
+      membership.worldEntity,
+      membership.materialHandle,
+      membership.drawItemIndex,
+      membership.passIndex
+    );
+    shadowCasterDrawKeys.add(key);
+    shadowCasterMembership.set(key, membership);
+    shadowCasterEntityKeys.add(membership.worldEntity);
+  }
   const postProcessParams = /* @__PURE__ */ new Map();
   const postProcessParamsQuery = world.query({ with: [PostProcessParams] }).unwrap();
   for (const row of postProcessParamsQuery) {
@@ -3510,6 +4085,9 @@ function extractFrame(world, context) {
     ...volumetricFog === void 0 ? {} : { volumetricFog },
     renderables,
     dispatch,
+    shadowCasterEntityKeys,
+    shadowCasterDrawKeys,
+    ...shadowCasterMembership.size === 0 ? {} : { shadowCasterMembership: [...shadowCasterMembership.values()] },
     skylight,
     skylightCount,
     lightProbes,
@@ -3519,19 +4097,21 @@ function extractFrame(world, context) {
     ...fogFailure === void 0 ? {} : { fogFailure },
     frustumStats: { culled: frustumCulled, total: frustumTotal },
     visibilityStats: { explicitlyHidden: explicitlyHidden.size },
+    materialTextureSources: materialTextureSourceStats,
     postProcessParams,
     visibilitySnapshots: [context.visibility],
     featureVisibilitySnapshots: [{ world, snapshot: context.visibility }],
     hiddenEntityReports: [...explicitlyHidden].map((entity) => ({ world, entity }))
   };
 }
+var DEFAULT_MATERIAL_SNAPSHOT = Object.freeze({
+  baseColor: vec3.create(0.5, 0.5, 0.5),
+  metallic: 0,
+  roughness: 1,
+  materialHandle: 0
+});
 function defaultMaterialSnapshot(materialHandle = 0) {
-  return {
-    baseColor: vec3.create(0.5, 0.5, 0.5),
-    metallic: 0,
-    roughness: 1,
-    materialHandle
-  };
+  return materialHandle === 0 ? DEFAULT_MATERIAL_SNAPSHOT : { ...DEFAULT_MATERIAL_SNAPSHOT, materialHandle };
 }
 function identityProjection() {
   const projection = new Float32Array(16);
@@ -3685,6 +4265,31 @@ function materialTextureFields(shaderId, fields) {
   }
   return fields;
 }
+function declaredMaterialTextureFields(shaderId, paramSchema, assets) {
+  return materialTextureFields(
+    shaderId,
+    paramSchema !== void 0 ? derive(paramSchema).textureFieldNames : shaderId !== void 0 ? assets.materialShaderTextureFieldNames(shaderId) : void 0
+  );
+}
+function collectAuthoredMaterialTextureFields(values, shaderId, paramSchema, assets) {
+  const fields = declaredMaterialTextureFields(shaderId, paramSchema, assets);
+  if (fields === void 0) return void 0;
+  const authored = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (Object.hasOwn(values, field)) authored.add(field);
+  }
+  return authored.size === 0 ? void 0 : authored;
+}
+function collectAuthoredMaterialSamplerFields(values, textureFields) {
+  const authored = /* @__PURE__ */ new Set();
+  for (const field of textureFields ?? []) {
+    if (materialTextureValue(values[field])?.sampler !== void 0) authored.add(field);
+  }
+  if (Object.hasOwn(values, "sampler") && values.sampler !== void 0) {
+    authored.add("baseColorTexture");
+  }
+  return authored.size === 0 ? void 0 : authored;
+}
 function runtimeMaterialShaderId(module, passName) {
   if (passName === "shadow-caster" && (module === "forgeax_material::standard" || module === "forgeax_material::unlit" || module === "forgeax::default-standard-pbr" || module === "forgeax::default-unlit")) {
     return "forgeax::default-shadow-caster";
@@ -3703,26 +4308,62 @@ function runtimeMaterialShaderId(module, passName) {
   }
 }
 function materialProgramKeysForMaterial(material, assets, context) {
+  return materialProgramKeysForAddress(material, assets, context, "direct");
+}
+function materialSceneIndexProgramKeysForMaterial(material, assets, context) {
   const projection = assets.getMaterialProjectionForPayload(material);
   if (projection === void 0) return void 0;
   if (context === void 0)
     throw new Error("Published material selection requires renderer-owned compiler context");
-  return Object.fromEntries(
-    projection.passes.map((pass) => {
-      const mode = String(
-        pass.renderState?.tags?.LightMode ?? pass.name
-      );
-      const selectedContext = {
-        ...context,
-        pass: /shadow/i.test(mode) ? "shadow" : /depth/i.test(mode) ? "depth" : "forward",
-        pipeline: /deferred|gbuffer/i.test(mode) ? "deferred" : context.pipeline
-      };
-      return [
+  const entries = {};
+  for (const pass of projection.passes) {
+    const mode = String(
+      pass.renderState?.tags?.LightMode ?? pass.name
+    );
+    const passKind = /shadow/i.test(mode) ? "shadow" : /depth/i.test(mode) ? "depth" : "forward";
+    const selectedContext = {
+      ...context,
+      pass: passKind,
+      pipeline: /deferred|gbuffer/i.test(mode) ? "deferred" : context.pipeline
+    };
+    try {
+      const selected = selectMaterialPassProgram(
+        projection,
         pass.name,
-        selectMaterialPassProgram(projection, pass.name, selectedContext).specializationKey
-      ];
-    })
-  );
+        selectedContext,
+        "scene-index"
+      );
+      entries[pass.name] = { specializationKey: selected.specializationKey, pass: passKind };
+    } catch (error) {
+      if (!isMissingMaterialProgram(error)) throw error;
+    }
+  }
+  return Object.keys(entries).length === 0 ? void 0 : entries;
+}
+function isMissingMaterialProgram(error) {
+  return error !== null && typeof error === "object" && error.code === "material-specialization-not-cooked";
+}
+function materialProgramKeysForAddress(material, assets, context, address) {
+  const projection = assets.getMaterialProjectionForPayload(material);
+  if (projection === void 0) return void 0;
+  if (context === void 0)
+    throw new Error("Published material selection requires renderer-owned compiler context");
+  const entries = [];
+  for (const pass of projection.passes) {
+    const mode = String(
+      pass.renderState?.tags?.LightMode ?? pass.name
+    );
+    const selectedContext = {
+      ...context,
+      pass: /shadow/i.test(mode) ? "shadow" : /depth/i.test(mode) ? "depth" : "forward",
+      pipeline: /deferred|gbuffer/i.test(mode) ? "deferred" : context.pipeline
+    };
+    entries.push([
+      pass.name,
+      selectMaterialPassProgram(projection, pass.name, selectedContext, address).specializationKey
+    ]);
+  }
+  return entries.length === 0 ? void 0 : Object.fromEntries(entries);
 }
 function runtimeMaterialShaderIdForMaterial(passes, programs) {
   const pass = passes.find(
@@ -3763,6 +4404,36 @@ function pipelineRenderState(renderState) {
     ...frontFace !== void 0 && { frontFace }
   };
 }
+function shadowCasterCpuReason(material, draw, shadowEntries, morph, skin) {
+  if (shadowEntries.length !== 1) return "multi-pass";
+  if (material.transparent === true || material.renderState?.blend !== void 0) {
+    return "transparent";
+  }
+  if (morph !== void 0) return "morph";
+  const shadowEntry = shadowEntries[0];
+  if (shadowEntry?.renderState !== void 0) return "unsupported-render-state";
+  if (draw === void 0) return "missing-gpu-draw";
+  if (draw.prepared === void 0) return "unprepared";
+  const preparedMaterial = draw.prepared.identity.material;
+  const preparedDeformation = draw.prepared.identity.deformation;
+  const materialContractMatches = preparedMaterial === material.materialShaderId;
+  const deformationContractMatches = skin === void 0 && preparedDeformation === "rigid" || skin !== void 0 && preparedDeformation === "skin";
+  if (!materialContractMatches || !deformationContractMatches) return "prepared-contract";
+  if (preparedDeformation === "skin" && !hasFiniteOrderedSkinBounds(skin?.bounds)) {
+    return "missing-skin-bounds";
+  }
+  return void 0;
+}
+function hasFiniteOrderedSkinBounds(bounds) {
+  if (bounds === void 0 || bounds.length !== 6) return false;
+  const minX = bounds[0];
+  const minY = bounds[1];
+  const minZ = bounds[2];
+  const maxX = bounds[3];
+  const maxY = bounds[4];
+  const maxZ = bounds[5];
+  return minX !== void 0 && minY !== void 0 && minZ !== void 0 && maxX !== void 0 && maxY !== void 0 && maxZ !== void 0 && Number.isFinite(minX) && Number.isFinite(minY) && Number.isFinite(minZ) && Number.isFinite(maxX) && Number.isFinite(maxY) && Number.isFinite(maxZ) && minX <= maxX && minY <= maxY && minZ <= maxZ;
+}
 var guidHandleInternByWorld = /* @__PURE__ */ new WeakMap();
 function internSharedRefFromGuid(world, assetsRef, guid, brand) {
   let perWorld = guidHandleInternByWorld.get(world);
@@ -3787,8 +4458,8 @@ function internSharedRefFromGuid(world, assetsRef, guid, brand) {
   return handle;
 }
 function resolveVideoFieldHandle(value, world, assetsRef) {
-  const texture = materialTextureValue(value);
-  const textureGuid = assetReferenceText(texture?.texture ?? value);
+  const texture2 = materialTextureValue(value);
+  const textureGuid = assetReferenceText(texture2?.texture ?? value);
   if (textureGuid === void 0) return void 0;
   const payload = assetsRef.lookup(textureGuid);
   if (payload === void 0 || payload.kind !== "video") return void 0;
@@ -3827,14 +4498,45 @@ function collectMaterialTextureCoordinates(values) {
   }
   return out;
 }
-function collectMaterialTextureSources(values, world) {
+function materialTextureSourceFields(schema) {
+  if (schema === void 0) return void 0;
+  const fields = /* @__PURE__ */ new Set();
+  for (const entry of schema) {
+    if (entry.type.startsWith("texture")) fields.add(entry.name);
+  }
+  return fields;
+}
+function collectMaterialTextureSources(values, world, textureFields, stats, cache) {
   const out = /* @__PURE__ */ new Map();
   for (const [field, value] of Object.entries(values)) {
-    const reference = materialTextureRef(value);
+    const structured = materialTextureValue(value);
+    const schemaKnown = textureFields !== void 0;
+    const schemaAdmitted = textureFields?.has(field) === true;
+    if (schemaKnown && !schemaAdmitted) continue;
+    const reference = structured?.texture ?? value;
+    if (stats !== void 0) stats.sourceFieldsVisited += 1;
     if (typeof reference !== "number") continue;
-    const resolved = world.sharedRefs.resolve(toShared(reference));
-    if (!resolved.ok || resolveRenderTargetMaterialSource(resolved.value) === void 0) continue;
-    out.set(field, resolved.value);
+    if (stats !== void 0) stats.numericSharedRefProbes += 1;
+    let source;
+    if (cache?.has(reference) === true) {
+      if (stats !== void 0) stats.sourceCacheHits += 1;
+      source = cache.get(reference) ?? void 0;
+    } else {
+      if (stats !== void 0) stats.sourceCacheMisses += 1;
+      const resolved = world.sharedRefs.resolve(toShared(reference));
+      if (!resolved.ok) {
+        cache?.set(reference, null);
+      } else {
+        const binding = resolveRenderTargetMaterialSource(resolved.value);
+        cache?.set(reference, binding === void 0 ? null : resolved.value);
+        source = binding === void 0 ? void 0 : resolved.value;
+      }
+    }
+    if (source === void 0) continue;
+    if (stats !== void 0) {
+      stats.producerRoutes.renderTarget = (stats.producerRoutes.renderTarget ?? 0) + 1;
+    }
+    out.set(field, source);
   }
   return out;
 }
@@ -3871,6 +4573,17 @@ var ENGINE_INJECTED_TEXTURE_FIELDS = /* @__PURE__ */ new Set(["emissiveTexture",
 function isEngineInjectedTextureField(shaderId, fieldName) {
   return isStandardPbrMaterialShader(shaderId) && ENGINE_INJECTED_TEXTURE_FIELDS.has(fieldName);
 }
+function materialStandardTextureMask(parameters, shaderId, values) {
+  return isCanonicalStandardPbrMaterialShader(shaderId) ? standardTextureMask(
+    // Canonical materials may provide values without redeclaring the root
+    // schema. Pruning must agree with the texture binder in that route too.
+    DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter(
+      (entry) => entry.type === "texture2d" && (values[entry.name] !== void 0 || parameters?.some(
+        (parameter) => parameter.name === entry.name && parameter.default !== void 0
+      ))
+    )
+  ) : void 0;
+}
 function materialParametersToParamSchema(parameters, shaderId) {
   if (isCanonicalStandardPbrMaterialShader(shaderId)) return STANDARD_PIPELINE_PARAM_SCHEMA;
   return materialParametersToParamSchema$1(parameters);
@@ -3950,7 +4663,7 @@ function storeMaterialSnapshot(cache, handleRaw, snapshot, passes, root, assets)
   cache.set(handleRaw, entry);
   return entry;
 }
-function resolveMaterialSnapshot(handleRaw, world, assetsRef, materialSnapshotCache, persistentMaterialSnapshotCache, materialContext) {
+function resolveMaterialSnapshot(handleRaw, world, assetsRef, materialSnapshotCache, persistentMaterialSnapshotCache, materialContext, materialTextureSourceStats, materialTextureSourceCache) {
   if (handleRaw === 0) return defaultMaterialSnapshot(handleRaw);
   const cached = materialSnapshotCache?.get(handleRaw);
   if (cached !== void 0) return cached.snapshot;
@@ -3982,6 +4695,11 @@ function resolveMaterialSnapshot(handleRaw, world, assetsRef, materialSnapshotCa
   const resolved = resolvedResult.value;
   const allPasses = resolved.passes;
   const materialProgramKeys = materialProgramKeysForMaterial(asset, assetsRef, materialContext);
+  const materialSceneIndexProgramKeys = materialSceneIndexProgramKeysForMaterial(
+    asset,
+    assetsRef,
+    materialContext
+  );
   const authoredFirstPassShader = runtimeMaterialShaderIdForMaterial(allPasses, void 0);
   const firstPassShader = runtimeMaterialShaderIdForMaterial(allPasses, materialProgramKeys);
   const pv = materialValuesToLinearRuntime(
@@ -4033,7 +4751,13 @@ function resolveMaterialSnapshot(handleRaw, world, assetsRef, materialSnapshotCa
     pv,
     (value) => resolveTexLike(materialTextureRef(value), "SamplerAsset")
   );
-  const textureSources = collectMaterialTextureSources(pv, world);
+  const textureSources = collectMaterialTextureSources(
+    pv,
+    world,
+    materialTextureSourceFields(materialParamSchema.length > 0 ? materialParamSchema : void 0),
+    materialTextureSourceStats,
+    materialTextureSourceCache
+  );
   const emissiveTextureHandle = resolveTexLike(
     materialTextureRef(pv.emissiveTexture),
     "TextureAsset"
@@ -4061,10 +4785,12 @@ function resolveMaterialSnapshot(handleRaw, world, assetsRef, materialSnapshotCa
     normalScale: normalScalePv,
     materialShaderId: firstPassShader,
     materialProgramKeys,
+    materialSceneIndexProgramKeys,
     materialHandle: handleRaw,
     renderState: pipelineRenderState(allPasses[0]?.renderState),
     paramSnapshot: paramSnap,
     ...materialParamSchema.length > 0 && { materialParamSchema },
+    standardTextureMask: materialStandardTextureMask(resolved.parameters, firstPassShader, pv),
     ...textureCoordinates.size > 0 && { textureCoordinates },
     ...textureHandles.size > 0 && { textureHandles },
     ...textureSources.size > 0 && { textureSources },
@@ -4156,43 +4882,11 @@ function pssmSplit(nearPlane, farPlane, cascadeCount, splitLambda) {
   }
   return result;
 }
-var POINT_SHADOW_FACE_LOOK = [
-  vec3.create(1, 0, 0),
-  vec3.create(-1, 0, 0),
-  vec3.create(0, 1, 0),
-  vec3.create(0, -1, 0),
-  vec3.create(0, 0, 1),
-  vec3.create(0, 0, -1)
-];
-var POINT_SHADOW_FACE_UP = [
-  vec3.create(0, -1, 0),
-  vec3.create(0, -1, 0),
-  vec3.create(0, 0, 1),
-  vec3.create(0, 0, -1),
-  vec3.create(0, -1, 0),
-  vec3.create(0, -1, 0)
-];
 function buildPointShadowMatrices(lightPos, near, far) {
-  const fovY = Math.PI / 2;
-  const aspect = 1;
-  const proj = mat4.create();
-  mat4.perspective(proj, fovY, aspect, near, far);
-  const out = [];
-  for (let i = 0; i < 6; i++) {
-    const look = POINT_SHADOW_FACE_LOOK[i];
-    const up = POINT_SHADOW_FACE_UP[i];
-    const target = vec3.create(
-      (lightPos[0] ?? 0) + (look[0] ?? 0),
-      (lightPos[1] ?? 0) + (look[1] ?? 0),
-      (lightPos[2] ?? 0) + (look[2] ?? 0)
-    );
-    const view = mat4.create();
-    mat4.lookAt(view, lightPos, target, up);
-    const vp = mat4.create();
-    mat4.multiply(vp, proj, view);
-    out.push(vp);
-  }
-  return out;
+  return buildCubeCameraFaceViews({ position: lightPos, near, far }).map(({ viewProjection }) => {
+    for (const offset of [0, 4, 8, 12]) viewProjection[offset] = -(viewProjection[offset] ?? 0);
+    return viewProjection;
+  });
 }
 function computeDirectionalCsm(direction, config, cameraData) {
   const cascadeCount = Math.round(config.cascadeCount);
@@ -4243,7 +4937,8 @@ function computeDirectionalCsm(direction, config, cameraData) {
       resultLightViewProjs.push(new Float32Array(16));
       continue;
     }
-    const cascadeNear = cIdx === 0 ? sNear : splits[cIdx - 1] ?? sFar;
+    const previousSplit = splits[cIdx - 1] ?? sNear;
+    const cascadeNear = cIdx === 0 ? sNear : Math.max(sNear, previousSplit * (1 - config.cascadeBlend));
     const cascadeFar = splits[cIdx] ?? sFar;
     const corners = computeFrustumCorners(
       cameraVP,
@@ -4280,7 +4975,7 @@ function computeDirectionalCsm(direction, config, cameraData) {
       minY,
       maxY,
       minZ,
-      maxZ
+      maxZ: nearZ
     });
     resultLightViewProjs.push(new Float32Array(mat4.multiply(mat4.create(), orthoProj, lightView)));
   }
@@ -4311,15 +5006,32 @@ var ALL_VISIBLE = {
 function collectCameraSnapshots(world) {
   const worldInternal = createWorldInternalView(world);
   const cameras = [];
-  const cameraQuery = world.query({ read: [Camera], optional: [MotionBlur], with: [Transform, GlobalTransform] }).unwrap();
+  const cameraQuery = world.query({
+    read: [Camera],
+    optional: [MotionBlur, DynamicResolution, ScreenSpaceReflection],
+    with: [Transform, GlobalTransform]
+  }).unwrap();
   for (const row of cameraQuery) {
     const cam = row.get(Camera);
     const motionBlur = row.get(MotionBlur);
+    const dynamicResolution = row.get(DynamicResolution);
+    const screenSpaceReflection = row.get(ScreenSpaceReflection);
     const entity = row.entity;
     const view = worldInternal._getArrayView(entity, GlobalTransform, "world");
     if (view === void 0) continue;
     const worldMat = new Float32Array(view);
     const target = resolveCameraTarget(world, cam.target);
+    const hasNonDefaultOutput = cam.exposureMode !== CAMERA_EXPOSURE_MODE_MANUAL || cam.exposure !== 1 || cam.temperature !== 6504 || cam.tint !== 0 || cam.colorLut !== 0 || cam.colorLutStrength !== 0;
+    const output = hasNonDefaultOutput ? {
+      exposure: cameraExposureFromColumns(cam),
+      temperature: cam.temperature,
+      tint: cam.tint,
+      colorLut: cam.colorLut,
+      colorLutStrength: cam.colorLutStrength
+    } : void 0;
+    const antialias = antialiasFromF32(cam.antialias);
+    const dynamicResolutionResult = validateDynamicResolutionCamera(dynamicResolution, antialias);
+    if (!dynamicResolutionResult.ok) throw dynamicResolutionResult.error;
     cameras.push({
       entityKey: entity,
       ...target === void 0 ? {} : { target },
@@ -4338,7 +5050,9 @@ function collectCameraSnapshots(world) {
       tonemap: tonemapFromF32(cam.tonemap),
       exposure: cam.exposure,
       whitePoint: cam.whitePoint,
-      antialias: antialiasFromF32(cam.antialias),
+      ...output === void 0 ? {} : { output },
+      antialias,
+      ...dynamicResolutionResult.value === void 0 ? {} : { dynamicResolution: dynamicResolutionResult.value },
       bloom: bloomEnabledFromF32(cam.bloom),
       bloomThreshold: cam.bloomThreshold,
       bloomIntensity: cam.bloomIntensity,
@@ -4355,6 +5069,13 @@ function collectCameraSnapshots(world) {
           maxRadiusPixels: motionBlur.maxRadiusPixels,
           sampleCount: motionBlur.sampleCount
         }
+      },
+      ...screenSpaceReflection === void 0 ? {} : {
+        screenSpaceReflection: {
+          maxDistance: screenSpaceReflection.maxDistance,
+          thickness: screenSpaceReflection.thickness,
+          maxRoughness: screenSpaceReflection.maxRoughness
+        }
       }
     });
   }
@@ -4405,6 +5126,7 @@ function collectReflectionProbeFacts(world) {
       priority: probe.priority,
       intensity: probe.intensity,
       resolution: probe.resolution,
+      boxProjection: probe.boxProjection,
       revision: probe.invalidationVersion,
       updateIntent: reflectionProbeUpdateIntentFromF32(probe.updateIntent),
       invalidationVersion: probe.invalidationVersion
@@ -4412,14 +5134,15 @@ function collectReflectionProbeFacts(world) {
   }
   return facts;
 }
-function selectCameraRoles(world) {
+function selectCameraRoles(world, requestedEntityKey) {
   const cameras = collectCameraSnapshots(world);
   const displayEntities = cameras.filter((camera) => camera.target === void 0).map((camera) => camera.entityKey ?? 0);
+  const hasExplicitSelection = requestedEntityKey !== void 0;
   const activeCameraIndex = selectActiveCameraIndex(
     displayEntities,
-    getActiveCamera(world)?.entity
+    hasExplicitSelection ? requestedEntityKey : getActiveCamera(world)?.entity
   );
-  const displayEntityKey = displayEntities[activeCameraIndex] ?? displayEntities[0];
+  const displayEntityKey = hasExplicitSelection ? displayEntities[activeCameraIndex] : displayEntities[activeCameraIndex] ?? displayEntities[0];
   const display = displayEntityKey === void 0 ? [] : cameras.filter((camera) => camera.entityKey === displayEntityKey);
   const candidates = cameras.map((camera) => ({
     worldId: 0,
@@ -4456,7 +5179,9 @@ function prepareExtractContext(world, options = {}) {
     resourceOwnerFog: options.resourceOwnerFog,
     cull: options.cull ?? "self",
     cullCameras: options.cullCameras,
+    ...options.cameraEntityKey === void 0 ? {} : { cameraEntityKey: options.cameraEntityKey },
     renderables,
+    worldId: options.worldId ?? 0,
     renderableEntities: options.renderableEntities,
     retainHidden: options.retainHidden ?? false,
     visibility: renderables === "none" ? ALL_VISIBLE : resolveVisibility(world),
@@ -4514,9 +5239,9 @@ function selectFogFrame(world) {
   if (state.lkg !== void 0) return state.lkg;
   throw fogSelection.error;
 }
-function textureDigest(texture) {
+function textureDigest(texture2) {
   let hash = 2166136261;
-  for (const byte of texture.data) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+  for (const byte of texture2.data) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
   return `fnv1a:${hash.toString(16).padStart(8, "0")}`;
 }
 function extractVolumeSnapshot(world, assets, worldInternal) {
@@ -5178,6 +5903,6 @@ var ProbeBlendSceneProjection = class {
   }
 };
 
-export { InstanceBoundsCache, OcclusionRenderRuntime, PROBE_MAX_CONTRIBUTORS, ProbeBlendSceneProjection, SKYLIGHT_RECOVERY_FALLBACK, admitProbeContributors, blendLightProbes, buildRectAreaWorldFrame, createCookieProjectionMatrixData, createExtendedLightingState, extractFrames, fingerprintNumericArray, glyphTextLayoutSystem, primitiveKey, primitiveKeyId, projectExtendedLightingInspection, promoteExtendedLightingCandidate, recordExtendedLightingFailure, rectAreaFacesPoint, scaledProbeWeight, setOcclusionRuntimeTestHooks, viewKey, viewKeyId };
-//# sourceMappingURL=chunk-VSL23LZE.mjs.map
-//# sourceMappingURL=chunk-VSL23LZE.mjs.map
+export { InstanceBoundsCache, OcclusionRenderRuntime, PROBE_MAX_CONTRIBUTORS, ProbeBlendSceneProjection, SKYLIGHT_RECOVERY_FALLBACK, SSR_HISTORY_FORMAT, SsrHistoryOwner, admitProbeContributors, blendLightProbes, buildRectAreaWorldFrame, buildShadowFrusta, createCookieProjectionMatrixData, createExtendedLightingState, createSsrHistoryOwner, createSsrSpatialResources, estimateSsrSpatialMemory, extractFrames, fingerprintNumericArray, glyphTextLayoutSystem, primitiveKey, primitiveKeyId, projectExtendedLightingInspection, promoteExtendedLightingCandidate, recordExtendedLightingFailure, rectAreaFacesPoint, scaledProbeWeight, setOcclusionRuntimeTestHooks, viewKey, viewKeyId };
+//# sourceMappingURL=chunk-C3DDSXYK.mjs.map
+//# sourceMappingURL=chunk-C3DDSXYK.mjs.map