@forgeax/engine-render 0.1.34 → 0.1.36

package/dist/{chunk-UI5SFODX.mjs → chunk-BZQ4CDRF.mjs}

@@ -1,1257 +1,2394 @@
-import { GlyphText } from './chunk-ILQ5MEZF.mjs';
-import { freezeBarrelDistortionMapping, MeshRenderer, MeshFilter, DirectionalLight, extractCloudLayer, validateDirectionalLightData, PointLight, computeInvRangeSquared, SpotLight, degToCos, RectAreaLight, validateRectAreaLightData, directionalShadowQualityFromF32, PointLightShadow, Skylight, LightProbe, validateLightProbeData, SkyboxBackground, Atmosphere, selectEnvironment, Instances, Layer, Points, Lines, SortKey, resolveMeshMaterialBindings, pointShapeFromU32, PostProcessParams, buildCubeCameraFaceViews, CubeCamera, cubeCameraUpdateIntentFromF32, ReflectionProbe, reflectionProbeUpdateIntentFromF32, tonemapToU32, resolveVisibility, Fog, VolumetricFog, resolveSelectedVolumetricLight, extractVolumetricFog, MotionBlur, DynamicResolution, ScreenSpaceReflection, DepthOfField, BarrelDistortion, Camera, cameraProjectionFromF32, resolveDepthOfFieldParams, depthOfFieldRequestFailure, CAMERA_EXPOSURE_MODE_MANUAL, cameraExposureFromColumns, antialiasFromF32, validateDynamicResolutionCamera, validateBarrelDistortionParameters, validateCameraBloom, tonemapFromF32 } from './chunk-UINHLCZA.mjs';
-import { SpriteRegionOverride, SpriteInstances, selectActiveCameraIndex, getActiveCamera } from './chunk-ELJFJ2BU.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-SHFUFJ5N.mjs';
-import { MotionBlurValidationError, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, SHADOW_ATLAS_DEFAULT_LAYERS, MaterialSkinAttrMissingError, SkinMaterialMismatchError, validateInstanceTransforms, ShadowInvalidConfigError, resolveMotionBlurParams, 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 } from './chunk-WEX45HKH.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 { Time } from '@forgeax/engine-ecs';
+import { GlyphText, SpriteRegionOverride, SpriteInstances, selectActiveCameraIndex, getActiveCamera } from './chunk-X2KA6WHM.mjs';
+import { RenderIntentInvalidError, DynamicResolutionRequiresTaaError, ShadowInvalidConfigError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, VolumeOwnerConflictError, MotionBlurValidationError, gpuDrivenShadowDrawKey, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, IES_SLICE_CAPACITY, COOKIE_SLICE_CAPACITY, SHADOW_ATLAS_DEFAULT_LAYERS, MaterialSkinAttrMissingError, isStandardPbrSkinMaterialShader, SkinMaterialMismatchError, validateInstanceTransforms, buildGpuDrivenDraws, deriveInstancesUnionBounds, worldEntityKey, gpuDrivenSourceDrawItemIndex, selectPasses, resolveRenderTargetMaterialSource, isCanonicalStandardPbrMaterialShader, BarrelDistortionInvalidParameterError, DynamicResolutionInvalidParameterError, COOKIE_SLICE_SIZE, EnvironmentSourceConflictError, FogCardinalityError, resolveMotionBlurParams, isStandardPbrMaterialShader, AtmosphereInvalidParameterError } from './chunk-2OZAS3WU.mjs';
+import { defineComponent, Entity, Time } from '@forgeax/engine-ecs';
+import { R_MIN, err, ok, TextError, toShared, handleSlot, AssetError, ASSET_ERROR_HINTS, materialValuesToLinearRuntime, derive, unpackSlot, materialGuidText } from '@forgeax/engine-types';
+import { TONEMAP_SHADER_MODE, standardTextureMask, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, STANDARD_PIPELINE_PARAM_SCHEMA, DEFAULT_STANDARD_SURFACE_MODULE } from '@forgeax/engine-shader';
 import { SpawnLightInvalidBoundsError, routeWorldError, SpriteInstancesMutuallyExclusiveWithInstancesError, SpriteInstancesRequiresSpriteShaderError, SpriteInstancesCountMismatchError, readRenderArrayView } from '@forgeax/engine-ecs/projection';
+import { Transform, projectHierarchy, GlobalTransform, MorphWeights } from '@forgeax/engine-scene';
 import { vec3, mat4, frustum, box3 } from '@forgeax/engine-math';
+import { resolveAssetHandle, walkMaterialPassesOverSharedRefs, selectMaterialPassProgram, materialParametersToParamSchema as materialParametersToParamSchema$1 } from '@forgeax/engine-assets-runtime';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
-import { Transform, GlobalTransform, MorphWeights } from '@forgeax/engine-scene';
-import { standardTextureMask, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, STANDARD_PIPELINE_PARAM_SCHEMA, DEFAULT_STANDARD_SURFACE_MODULE } from '@forgeax/engine-shader';
+import { RhiError } from '@forgeax/engine-rhi';
 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");
+var Atmosphere = defineComponent("Atmosphere", {
+  turbidity: { type: "f32", default: 2 },
+  rayleigh: { type: "f32", default: 1 },
+  mieCoefficient: { type: "f32", default: 5e-3 },
+  mieDirectionalG: { type: "f32", default: 0.8 },
+  sunAngularRadius: { type: "f32", default: 4675e-6 },
+  /** Independent multiplier for the analytic circumsolar lobe. */
+  circumsolarStrength: { type: "f32", default: 1 },
+  /** Relative angular width of the analytic circumsolar lobe. */
+  circumsolarWidth: { type: "f32", default: 1 }
+});
+var BarrelDistortion = defineComponent("BarrelDistortion", {
+  strength: { type: "f32", default: 0 },
+  centerX: { type: "f32", default: 0.5 },
+  centerY: { type: "f32", default: 0.5 }
+});
+var DEFAULT_BARREL_DISTORTION = Object.freeze({
+  strength: 0,
+  centerX: 0.5,
+  centerY: 0.5
+});
+function invalid(field, value, expected) {
+  return new BarrelDistortionInvalidParameterError({ field, value, expected });
+}
+function validateBarrelDistortionParameters(input) {
+  const value = input ?? {};
+  const strength = value.strength ?? DEFAULT_BARREL_DISTORTION.strength;
+  const centerX = value.centerX ?? DEFAULT_BARREL_DISTORTION.centerX;
+  const centerY = value.centerY ?? DEFAULT_BARREL_DISTORTION.centerY;
+  if (!Number.isFinite(strength) || strength < 0 || strength > 0.35) {
+    return err(invalid("strength", strength, "finite and in [0, 0.35]"));
+  }
+  if (!Number.isFinite(centerX) || centerX < 0 || centerX > 1) {
+    return err(invalid("centerX", centerX, "finite and in [0, 1]"));
+  }
+  if (!Number.isFinite(centerY) || centerY < 0 || centerY > 1) {
+    return err(invalid("centerY", centerY, "finite and in [0, 1]"));
+  }
+  return ok(Object.freeze({ strength, centerX, centerY }));
+}
+var CAMERA_PROJECTION_PERSPECTIVE = 0;
+var CAMERA_PROJECTION_ORTHOGRAPHIC = 1;
+var CAMERA_EXPOSURE_MODE_MANUAL = 0;
+var CAMERA_EXPOSURE_MODE_AUTO = 1;
+var CAMERA_TEMPERATURE_MIN = 1e3;
+var CAMERA_TEMPERATURE_MAX = 4e4;
+var CAMERA_TINT_MIN = -1;
+var CAMERA_TINT_MAX = 1;
+var CameraError = class extends Error {
+  code;
+  expected;
+  hint;
+  detail;
+  constructor(code, field, actual, expected, hint) {
+    super(`${code}: ${field}=${String(actual)}; expected ${expected}`);
+    this.name = "CameraError";
+    this.code = code;
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = Object.freeze({ field, actual, expected });
+  }
+};
+function actualValue(value) {
+  if (typeof value === "number" || typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
   }
 }
-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 cameraError(code, field, actual, expected, hint) {
+  return new CameraError(code, field, actualValue(actual), expected, hint);
 }
-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 })
-  });
+function finitePositive(value) {
+  return Number.isFinite(value) && value > 0;
 }
-
-// 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 validateCameraExposure(exposure) {
+  if (typeof exposure !== "object" || exposure === null) {
+    throw cameraError(
+      "camera-exposure-invalid",
+      "value",
+      exposure,
+      "an object with kind manual or auto",
+      "choose one member of the CameraExposure union"
+    );
+  }
+  if (exposure.kind === "manual") {
+    if (!finitePositive(exposure.multiplier)) {
+      throw cameraError(
+        "camera-exposure-invalid",
+        "multiplier",
+        exposure.multiplier,
+        "a finite number greater than zero",
+        "set Camera.exposure to a positive finite manual multiplier"
+      );
+    }
+    return exposure;
+  }
+  if (exposure.kind === "auto") {
+    const [min, max] = exposure.rangeEv;
+    const [up, down] = exposure.rates;
+    if (!finitePositive(exposure.fallback) || !Number.isFinite(exposure.compensationEv) || !Number.isFinite(min) || !Number.isFinite(max) || min > max || !Number.isFinite(up) || !Number.isFinite(down) || up < 0 || down < 0) {
+      throw cameraError(
+        "camera-exposure-invalid",
+        "auto",
+        JSON.stringify(exposure),
+        "finite fallback/compensation, an ordered range, and non-negative rates",
+        "inspect fallback, compensationEv, rangeEv, and rates before rebuilding the camera"
+      );
+    }
+    return exposure;
+  }
+  throw cameraError(
+    "camera-exposure-invalid",
+    "kind",
+    exposure.kind,
+    "'manual' or 'auto'",
+    "choose one member of the CameraExposure union"
+  );
 }
-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");
+function validateCameraColorGrading(temperature, tint, colorLutStrength) {
+  if (!Number.isFinite(temperature) || temperature < CAMERA_TEMPERATURE_MIN || temperature > CAMERA_TEMPERATURE_MAX) {
+    throw cameraError(
+      "camera-color-grading-invalid",
+      "temperature",
+      temperature,
+      `a finite value in [${CAMERA_TEMPERATURE_MIN}, ${CAMERA_TEMPERATURE_MAX}]`,
+      "set Camera.temperature to a supported Kelvin value"
+    );
+  }
+  if (!Number.isFinite(tint) || tint < CAMERA_TINT_MIN || tint > CAMERA_TINT_MAX) {
+    throw cameraError(
+      "camera-color-grading-invalid",
+      "tint",
+      tint,
+      `a finite value in [${CAMERA_TINT_MIN}, ${CAMERA_TINT_MAX}]`,
+      "set Camera.tint to a normalized value between -1 and 1"
+    );
+  }
+  if (!Number.isFinite(colorLutStrength) || colorLutStrength < 0 || colorLutStrength > 1) {
+    throw cameraError(
+      "camera-color-grading-invalid",
+      "colorLutStrength",
+      colorLutStrength,
+      "a finite value in [0, 1]",
+      "set Camera.colorLutStrength to zero to disable the LUT or a blend in [0, 1]"
+    );
   }
-  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
+function cameraProjectionFromF32(value) {
+  return value === CAMERA_PROJECTION_ORTHOGRAPHIC ? "orthographic" : "perspective";
+}
+var TONEMAP_NONE = TONEMAP_SHADER_MODE.none;
+var TONEMAP_REINHARD_EXTENDED = TONEMAP_SHADER_MODE.reinhardExtended;
+var TONEMAP_REINHARD = TONEMAP_SHADER_MODE.reinhard;
+var TONEMAP_LINEAR = TONEMAP_SHADER_MODE.linear;
+var TONEMAP_CINEON = TONEMAP_SHADER_MODE.cineon;
+var TONEMAP_ACES_FILMIC = TONEMAP_SHADER_MODE.acesFilmic;
+var TONEMAP_AGX = TONEMAP_SHADER_MODE.agx;
+var TONEMAP_NEUTRAL = TONEMAP_SHADER_MODE.neutral;
+function tonemapFromF32(value) {
+  switch (value) {
+    case TONEMAP_REINHARD_EXTENDED:
+      return "reinhard-extended";
+    case TONEMAP_REINHARD:
+      return "reinhard";
+    case TONEMAP_LINEAR:
+      return "linear";
+    case TONEMAP_CINEON:
+      return "cineon";
+    case TONEMAP_ACES_FILMIC:
+      return "aces-filmic";
+    case TONEMAP_AGX:
+      return "agx";
+    case TONEMAP_NEUTRAL:
+      return "neutral";
+    default:
+      return "none";
+  }
+}
+function tonemapToU32(mode) {
+  switch (mode) {
+    case "reinhard-extended":
+      return TONEMAP_REINHARD_EXTENDED;
+    case "reinhard":
+      return TONEMAP_REINHARD;
+    case "linear":
+      return TONEMAP_LINEAR;
+    case "cineon":
+      return TONEMAP_CINEON;
+    case "aces-filmic":
+      return TONEMAP_ACES_FILMIC;
+    case "agx":
+      return TONEMAP_AGX;
+    case "neutral":
+      return TONEMAP_NEUTRAL;
+    case "none":
+      return TONEMAP_NONE;
+  }
+  throw cameraError(
+    "camera-tonemap-invalid",
+    "tonemap",
+    mode,
+    "one of the closed Tonemap values",
+    "select a supported Camera tonemap mode"
   );
-  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
-  });
+var ANTIALIAS_NONE = 0;
+var ANTIALIAS_FXAA = 1;
+var ANTIALIAS_MSAA = 2;
+var ANTIALIAS_TAA = 3;
+function antialiasFromF32(value) {
+  if (value === ANTIALIAS_NONE) return "none";
+  if (value === ANTIALIAS_FXAA) return "fxaa";
+  if (value === ANTIALIAS_MSAA) return "msaa";
+  if (value === ANTIALIAS_TAA) return "taa";
+  throw cameraError(
+    "camera-antialias-invalid",
+    "antialias",
+    value,
+    `${ANTIALIAS_NONE}, ${ANTIALIAS_FXAA}, ${ANTIALIAS_MSAA}, or ${ANTIALIAS_TAA}`,
+    "select a supported Camera antialias mode"
+  );
 }
-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 });
+var BLOOM_DISABLED = 0;
+var BLOOM_ENABLED = 1;
+var CAMERA_BLOOM_INTENSITY_MIN = 0;
+var CAMERA_BLOOM_INTENSITY_MAX = 8;
+var CAMERA_BLOOM_THRESHOLD_MIN = 0;
+var CAMERA_BLOOM_THRESHOLD_MAX = 65504;
+var CAMERA_BLOOM_SOFT_KNEE_MIN = 0;
+var CAMERA_BLOOM_SOFT_KNEE_MAX = 1;
+var CAMERA_BLOOM_SCATTER_MIN = 0;
+var CAMERA_BLOOM_SCATTER_MAX = 0.95;
+function bloomEnabledFromF32(value) {
+  if (value === BLOOM_DISABLED) return "off";
+  if (value === BLOOM_ENABLED) return "on";
+  throw cameraError(
+    "camera-bloom-invalid",
+    "bloom",
+    value,
+    `${BLOOM_DISABLED} or ${BLOOM_ENABLED}`,
+    "select Camera bloom off or on"
+  );
 }
-
-// src/inspection-types.ts
-function projectLightInspection(input) {
-  return Object.freeze({
-    generation: input.generation,
-    candidate: input.candidate,
-    accepted: input.accepted,
-    lastKnownGood: input.lastKnownGood,
-    failure: input.failure,
-    failureKeys: [...input.failureKeys],
-    resourceCount: input.resourceCount,
-    uploadBytes: input.uploadBytes
-  });
+function validateBloomRange(field, value, min, max) {
+  if (!Number.isFinite(value) || value < min || value > max) {
+    throw cameraError(
+      "camera-bloom-invalid",
+      field,
+      value,
+      `a finite value in [${min}, ${max}]`,
+      `set Camera.${field} to a finite value in [${min}, ${max}]`
+    );
+  }
 }
-function lightInspectionIdentity(topology, generation) {
-  return `${topology}:generation-${generation}`;
-}
-var emptyBloomInspection = () => ({
-  graphStatus: "empty",
-  enabled: false,
-  levelCount: 0,
-  levelDimensions: [],
-  downsamplePassCount: 0,
-  upsamplePassCount: 0,
-  targetCount: 0,
-  targetBytes: 0,
-  resourceCount: 0,
-  passCount: 0,
-  encodeCount: 0,
-  bindGroupCount: 0,
-  uploadCount: 0,
-  residentChildBytes: 0,
-  generation: 0,
-  state: "off"
+function validateCameraBloom(bloom, threshold, intensity, softKnee, scatter) {
+  const enabled = bloomEnabledFromF32(bloom);
+  validateBloomRange(
+    "bloomThreshold",
+    threshold,
+    CAMERA_BLOOM_THRESHOLD_MIN,
+    CAMERA_BLOOM_THRESHOLD_MAX
+  );
+  validateBloomRange(
+    "bloomIntensity",
+    intensity,
+    CAMERA_BLOOM_INTENSITY_MIN,
+    CAMERA_BLOOM_INTENSITY_MAX
+  );
+  validateBloomRange(
+    "bloomSoftKnee",
+    softKnee,
+    CAMERA_BLOOM_SOFT_KNEE_MIN,
+    CAMERA_BLOOM_SOFT_KNEE_MAX
+  );
+  validateBloomRange("bloomScatter", scatter, CAMERA_BLOOM_SCATTER_MIN, CAMERA_BLOOM_SCATTER_MAX);
+  return enabled;
+}
+var Camera = defineComponent("Camera", {
+  fov: { type: "f32" },
+  aspect: { type: "f32" },
+  near: { type: "f32" },
+  far: { type: "f32" },
+  projection: { type: "f32", default: 0 },
+  left: { type: "f32", default: -1 },
+  right: { type: "f32", default: 1 },
+  bottom: { type: "f32", default: -1 },
+  top: { type: "f32", default: 1 },
+  tonemap: { type: "f32", default: 0 },
+  exposure: { type: "f32", default: 1 },
+  exposureMode: { type: "f32", default: CAMERA_EXPOSURE_MODE_MANUAL },
+  compensationEv: { type: "f32", default: 0 },
+  rangeEv: { type: "array<f32, 2>", default: new Float32Array([-8, 8]) },
+  rates: { type: "array<f32, 2>", default: new Float32Array([3, 1]) },
+  whitePoint: { type: "f32", default: 4 },
+  temperature: { type: "f32", default: 6504 },
+  tint: { type: "f32", default: 0 },
+  colorLut: { type: "shared<TextureAsset>", default: 0 },
+  colorLutStrength: { type: "f32", default: 0 },
+  antialias: { type: "f32", default: 0 },
+  historyVersion: { type: "u32", default: 0 },
+  bloom: { type: "f32", default: 0 },
+  bloomThreshold: { type: "f32", default: 1 },
+  bloomIntensity: { type: "f32", default: 1 },
+  bloomSoftKnee: { type: "f32", default: 0.5 },
+  bloomScatter: { type: "f32", default: 0.7 },
+  // M1 target camera role: zero means this camera is eligible for display;
+  // non-zero shared targets are auxiliary producers whose views and receipt
+  // promotion remain owned by Renderer.
+  target: { type: "shared<RenderTarget>", simulationTransient: true },
+  // feat-20260709 M3 / D-3: clear-color is one inline `array<f32,4>` column.
+  // The earlier 4-scalar form (clearR/G/B/A) was chosen when this was believed
+  // to be the only SoA-safe shape; the Transform (pos/quat/scale) and light
+  // (direction/color) precedents disprove that -- an `array<f32,N>` IS an
+  // inline stride-N SoA column, read on the hot path as `col[i*N+a]` with zero
+  // allocation, so collapsing four scalars into one column removes three field
+  // names a reader must track without changing the storage layout or read
+  // pattern. The default `[0, 0, 0, 0]` is transparent black; explicit alpha
+  // stays visible through the same public array field.
+  clearColor: { type: "array<f32, 4>", default: new Float32Array([0, 0, 0, 0]) },
+  // feat-20260617-host-engine-contract-and-video-cutscene / M3 / D-4: the
+  // aspect-sync sidecar on the createApp(canvas) path writes
+  // canvas.width / canvas.height into `aspect` every frame when this flag is
+  // true. Reuses the existing `bool` column tier (AnimationPlayer.paused /
+  // AudioSource.playing precedent) -- zero ECS infrastructure change. Default
+  // true so demos that never touch aspect track the canvas automatically
+  // (charter P1 default-is-correct); set false for render-to-texture /
+  // split-screen cameras that drive aspect themselves. Read it via
+  // world.get (readRow narrows bool -> JS boolean); the query-bundle path
+  // returns a raw 0/1 number (the `!== 0` always-true trap).
+  autoAspect: { type: "bool", default: true }
 });
-function projectBarrelDistortionInspection(input) {
-  const effectiveMapping = input.effectiveMapping === void 0 ? void 0 : freezeBarrelDistortionMapping(input.effectiveMapping);
-  return Object.freeze({
-    effectiveMapping,
-    extent: effectiveMapping === void 0 ? void 0 : Object.freeze({ width: effectiveMapping.width, height: effectiveMapping.height }),
-    frameId: input.frameId,
-    deviceGeneration: input.deviceGeneration,
-    graphGeneration: input.graphGeneration,
-    lastKnownGood: input.lastKnownGood
-  });
+function cameraExposureFromColumns(input) {
+  if (input.exposureMode === CAMERA_EXPOSURE_MODE_MANUAL) {
+    return validateCameraExposure({ kind: "manual", multiplier: input.exposure });
+  }
+  if (input.exposureMode === CAMERA_EXPOSURE_MODE_AUTO) {
+    return validateCameraExposure({
+      kind: "auto",
+      fallback: input.exposure,
+      compensationEv: input.compensationEv,
+      rangeEv: [input.rangeEv[0] ?? -8, input.rangeEv[1] ?? 8],
+      rates: [input.rates[0] ?? 3, input.rates[1] ?? 1]
+    });
+  }
+  throw cameraError(
+    "camera-exposure-mode-invalid",
+    "exposureMode",
+    input.exposureMode,
+    `${CAMERA_EXPOSURE_MODE_MANUAL} or ${CAMERA_EXPOSURE_MODE_AUTO}`,
+    "set Camera.exposureMode to the manual or auto encoding"
+  );
 }
-
-// src/prepare/extended-lighting/state.ts
-function createExtendedLightingState(generation) {
+function cameraExposureColumns(exposure) {
+  const checked = validateCameraExposure(exposure);
+  if (checked.kind === "manual") {
+    return {
+      exposureMode: CAMERA_EXPOSURE_MODE_MANUAL,
+      exposure: checked.multiplier,
+      compensationEv: 0,
+      rangeEv: new Float32Array([-8, 8]),
+      rates: new Float32Array([3, 1])
+    };
+  }
   return {
-    enabled: false,
-    generation,
-    status: "empty",
-    candidate: void 0,
-    accepted: void 0,
-    lastKnownGood: void 0,
-    resourceCount: 0,
-    descriptorBytes: 0,
-    uploadCount: 0,
-    passCount: 0,
-    bindGroupCount: 0,
-    failure: void 0,
-    failureKeys: []
+    exposureMode: CAMERA_EXPOSURE_MODE_AUTO,
+    exposure: checked.fallback,
+    compensationEv: checked.compensationEv,
+    rangeEv: new Float32Array(checked.rangeEv),
+    rates: new Float32Array(checked.rates)
   };
 }
-function promoteExtendedLightingCandidate(state, candidate) {
-  if (candidate === void 0) return state;
+function cameraColorGradingColumns(opts) {
+  const exposure = opts.exposure ?? { kind: "manual", multiplier: 1 };
+  const temperature = opts.temperature ?? 6504;
+  const tint = opts.tint ?? 0;
+  const colorLutStrength = opts.colorLutStrength ?? 0;
+  validateCameraColorGrading(temperature, tint, colorLutStrength);
   return {
-    ...state,
-    enabled: true,
-    generation: candidate.generation,
-    status: "accepted",
-    candidate: void 0,
-    accepted: candidate,
-    lastKnownGood: candidate,
-    resourceCount: 4,
-    descriptorBytes: candidate.descriptorBytes,
-    uploadCount: candidate.uploadCount
+    ...cameraExposureColumns(exposure),
+    temperature,
+    tint,
+    colorLut: opts.colorLut ?? 0,
+    colorLutStrength
   };
 }
-function recordExtendedLightingFailure(state, failure2) {
-  const key = `${failure2.detail.entity}:${failure2.detail.feature}:${failure2.detail.generation}`;
-  if (state.failureKeys.includes(key)) return state;
+function cameraPodFromDefaults() {
+  const base = {};
+  for (const [key, field] of Object.entries(Camera.fields)) {
+    if ("default" in field && field.default !== void 0) {
+      base[key] = field.default;
+    }
+  }
+  return base;
+}
+function perspective(opts) {
   return {
-    ...state,
-    failure: failure2,
-    failureKeys: [...state.failureKeys, key]
+    // cameraPodFromDefaults() reads autoAspect's schema default (true), so an
+    // omitted opts.autoAspect lands the default-correct value; an explicit
+    // false overrides it below (D-4: factory one-step opt-out, charter P1).
+    ...cameraPodFromDefaults(),
+    fov: opts.fov,
+    aspect: opts.aspect,
+    near: opts.near ?? 0.1,
+    far: opts.far ?? 100,
+    projection: CAMERA_PROJECTION_PERSPECTIVE,
+    ...opts.autoAspect !== void 0 ? { autoAspect: opts.autoAspect } : {},
+    ...cameraColorGradingColumns(opts)
   };
 }
-function projectExtendedLightingInspection(state) {
-  const identity = (candidate) => candidate === void 0 ? void 0 : lightInspectionIdentity(candidate.topology, candidate.generation);
-  return projectLightInspection({
-    generation: state.generation,
-    candidate: identity(state.candidate),
-    accepted: identity(state.accepted),
-    lastKnownGood: identity(state.lastKnownGood),
-    failure: state.failure?.code,
-    failureKeys: state.failureKeys,
-    resourceCount: state.resourceCount,
-    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
+function orthographic(opts) {
+  return {
+    ...cameraPodFromDefaults(),
+    fov: 0,
+    aspect: 1,
+    near: opts.near ?? 0.1,
+    far: opts.far ?? 100,
+    projection: CAMERA_PROJECTION_ORTHOGRAPHIC,
+    left: opts.left,
+    right: opts.right,
+    bottom: opts.bottom,
+    top: opts.top,
+    ...cameraColorGradingColumns(opts)
   };
-  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;
+}
+var CloudQualityValue = Object.freeze({
+  low: 0,
+  medium: 1,
+  high: 2
+});
+var CloudLayer = defineComponent("CloudLayer", {
+  /** Stable integer seed for the periodic 3D density field. */
+  seed: { type: "u32", default: 1337 },
+  /** World-space lower edge of the layer, in metres. */
+  baseHeight: { type: "f32", default: 120 },
+  /** World-space thickness of the layer, in metres. */
+  thickness: { type: "f32", default: 80 },
+  /** Horizontal noise scale, in cycles per metre. */
+  scale: { type: "f32", default: 4e-3 },
+  /** Coverage threshold in [0, 1]. */
+  coverage: { type: "f32", default: 0.48 },
+  /** Extinction multiplier in inverse metres. */
+  density: { type: "f32", default: 1 },
+  /** World-space wind velocity in metres per second. */
+  wind: { type: "array<f32, 3>", default: new Float32Array([8, 0, 2]) },
+  /** Quality controls cache resolution and bounded ray steps. */
+  quality: { type: "f32", default: CloudQualityValue.medium },
+  /** Maximum world-space distance represented by the light-space shadow map. */
+  shadowRange: { type: "f32", default: 512 }
+});
+function cloudQualityFromF32(value) {
+  if (value === CloudQualityValue.low) return "low";
+  if (value === CloudQualityValue.medium) return "medium";
+  if (value === CloudQualityValue.high) return "high";
+  return void 0;
+}
+var CUBE_CAMERA_UPDATE_ONCE = 0;
+var CUBE_CAMERA_UPDATE_ON_DEMAND = 1;
+var CUBE_CAMERA_UPDATE_CONTINUOUS = 2;
+var CUBE_CAMERA_FACE_ORDER = ["+X", "-X", "+Y", "-Y", "+Z", "-Z"];
+function cubeCameraUpdateIntentFromF32(value) {
+  switch (value) {
+    case CUBE_CAMERA_UPDATE_ONCE:
+      return "once";
+    case CUBE_CAMERA_UPDATE_ON_DEMAND:
+      return "on-demand";
+    case CUBE_CAMERA_UPDATE_CONTINUOUS:
+      return "continuous";
+    default:
+      throw new RenderIntentInvalidError("CubeCamera", value);
+  }
+}
+function cubeCameraUpdateIntentToF32(intent) {
+  switch (intent) {
+    case "once":
+      return CUBE_CAMERA_UPDATE_ONCE;
+    case "on-demand":
+      return CUBE_CAMERA_UPDATE_ON_DEMAND;
+    case "continuous":
+      return CUBE_CAMERA_UPDATE_CONTINUOUS;
+  }
+}
+var CubeCamera = defineComponent("CubeCamera", {
+  target: { type: "shared<RenderTarget>", simulationTransient: true },
+  near: { type: "f32", default: 0.1 },
+  far: { type: "f32", default: 100 },
+  updateIntent: { type: "f32", default: CUBE_CAMERA_UPDATE_ONCE },
+  requestVersion: { type: "u32", default: 0 },
+  faceBudget: { type: "u32", default: 1 }
+});
+var DepthOfFieldQualityValue = Object.freeze({
+  low: 0,
+  medium: 1,
+  high: 2
+});
+var DepthOfFieldSideValue = Object.freeze({
+  both: 0,
+  near: 1,
+  far: 2
+});
+var DepthOfField = defineComponent("DepthOfField", {
+  focusDistance: { type: "f32", default: 8 },
+  fStop: { type: "f32", default: 2.8 },
+  sensorHeight: { type: "f32", default: 0.024 },
+  maxRadiusPixels: { type: "f32", default: 16 },
+  quality: { type: "f32", default: DepthOfFieldQualityValue.medium },
+  blurSide: { type: "f32", default: DepthOfFieldSideValue.both }
+});
+function depthOfFieldQualityFromF32(value) {
+  if (value === DepthOfFieldQualityValue.low) return "low";
+  if (value === DepthOfFieldQualityValue.medium) return "medium";
+  if (value === DepthOfFieldQualityValue.high) return "high";
+  return void 0;
+}
+function depthOfFieldSideFromF32(value) {
+  if (value === DepthOfFieldSideValue.both) return "both";
+  if (value === DepthOfFieldSideValue.near) return "near";
+  if (value === DepthOfFieldSideValue.far) return "far";
+  return void 0;
+}
+
+// src/components/directional-shadow-filter.ts
+var DirectionalShadowFilterValue = Object.freeze({
+  pcf1: 1,
+  pcf3: 2,
+  pcf5: 3,
+  pcssMedium: 4,
+  pcssHigh: 5
+});
+function directionalShadowQualityFromF32(value, angularRadiusRadians, maxPenumbraTexels) {
+  switch (value) {
+    case DirectionalShadowFilterValue.pcf1:
+      return { kind: "pcf", kernel: 1 };
+    case DirectionalShadowFilterValue.pcf3:
+      return { kind: "pcf", kernel: 3 };
+    case DirectionalShadowFilterValue.pcf5:
+      return { kind: "pcf", kernel: 5 };
+    case DirectionalShadowFilterValue.pcssMedium:
+      return {
+        kind: "pcss",
+        preset: "medium",
+        angularRadiusRadians,
+        maxPenumbraTexels
+      };
+    case DirectionalShadowFilterValue.pcssHigh:
+      return {
+        kind: "pcss",
+        preset: "high",
+        angularRadiusRadians,
+        maxPenumbraTexels
+      };
+    default:
+      return void 0;
   }
-  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;
+}
+var DirectionalLight = defineComponent("DirectionalLight", {
+  // direction is the ONLY field with no default (D-5): omitting it lands the
+  // array layer-3 all-zero [0,0,0], which the renderer owner rejects -- there is no
+  // universal default direction, so "default is illegal" forces an explicit
+  // non-zero value. color carries an explicit layer-2 default [1,1,1] (white);
+  // the array layer-3 fallback is all-zero, so the default MUST be explicit.
+  direction: { type: "array<f32, 3>" },
+  color: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  intensity: { type: "f32", default: 1 },
+  // Shadow opt-out gate: defaults to true so zero-config spawns get shadows.
+  castShadow: { type: "bool", default: true },
+  // 9 shadow fields migrated from DirectionalLightShadow (feat-20260621 M1).
+  cascadeCount: { type: "f32", default: 4 },
+  splitLambda: { type: "f32", default: 0.75 },
+  cascadeBlend: { type: "f32", default: 0.2 },
+  mapSize: { type: "f32", default: 2048 },
+  depthBias: { type: "f32", default: 1e-5 },
+  normalBias: { type: "f32", default: 0.05 },
+  // Sole shadow coverage knob (feat replaces nearPlane/farPlane). The PSSM
+  // near end derives from the active camera near; shadowDistance is the far
+  // reach. Default 200 world units (matches UE-style "dynamic shadow
+  // distance"; the old farPlane default was 50).
+  shadowDistance: { type: "f32", default: 200 },
+  shadowFilter: {
+    type: "enum",
+    default: DirectionalShadowFilterValue.pcf3,
+    labels: DirectionalShadowFilterValue
+  },
+  shadowAngularRadius: { type: "f32", default: 465e-5 },
+  maxPenumbraTexels: { type: "f32", default: 32 }
+});
+var DynamicResolution = defineComponent("DynamicResolution", {
+  targetGpuMs: { type: "f32", default: 16.67 },
+  minScale: { type: "f32", default: 0.67 },
+  maxScale: { type: "f32", default: 1 }
+});
+var DEFAULT_DYNAMIC_RESOLUTION = Object.freeze({
+  targetGpuMs: 16.67,
+  minScale: 0.67,
+  maxScale: 1
+});
+function invalid2(field, value, expected) {
+  return new DynamicResolutionInvalidParameterError({ field, value, expected });
+}
+function validateDynamicResolutionParameters(input) {
+  const value = input ?? {};
+  const targetGpuMs = value.targetGpuMs ?? DEFAULT_DYNAMIC_RESOLUTION.targetGpuMs;
+  const minScale = value.minScale ?? DEFAULT_DYNAMIC_RESOLUTION.minScale;
+  const maxScale = value.maxScale ?? DEFAULT_DYNAMIC_RESOLUTION.maxScale;
+  if (!Number.isFinite(targetGpuMs) || targetGpuMs <= 0) {
+    return err(invalid2("targetGpuMs", targetGpuMs, "finite and greater than 0"));
+  }
+  if (!Number.isFinite(minScale) || minScale < 0.5 || minScale > 1) {
+    return err(invalid2("minScale", minScale, "finite and in [0.5, 1.0]"));
+  }
+  if (!Number.isFinite(maxScale) || maxScale < 0.5 || maxScale > 1) {
+    return err(invalid2("maxScale", maxScale, "finite and in [0.5, 1.0]"));
+  }
+  if (minScale > maxScale) {
+    return err(invalid2("minScale", minScale, "less than or equal to maxScale"));
+  }
+  return ok(Object.freeze({ targetGpuMs, minScale, maxScale }));
+}
+function validateDynamicResolutionCamera(input, antialias) {
+  if (input === void 0) return ok(void 0);
+  const parameters = validateDynamicResolutionParameters(input);
+  if (!parameters.ok) return parameters;
+  if (antialias !== "taa") {
+    return err(new DynamicResolutionRequiresTaaError({ antialias }));
+  }
+  return parameters;
+}
+var Fog = defineComponent("Fog", {
+  color: { type: "array<f32, 3>", default: new Float32Array([0.5, 0.5, 0.5]) },
+  density: { type: "f32", default: 0.01 },
+  heightFalloff: { type: "f32", default: 0 },
+  maxOpacity: { type: "f32", default: 1 }
+});
+var Instances = defineComponent("Instances", {
+  transforms: { type: "array<f32>" }
+});
+var Layer = defineComponent("Layer", {
+  value: { type: "i32", default: 0 }
+});
+
+// src/components/light-helpers.ts
+var RANGE_ZERO_FALLBACK_INV_R2 = 1e8;
+var DEG_TO_RAD = Math.PI / 180;
+var PCSS_RADIUS_MIN = 1e-4;
+var PCSS_RADIUS_MAX = 0.05;
+var PCSS_PENUMBRA_MIN = 1;
+var PCSS_PENUMBRA_MAX = 64;
+function degToCos(deg) {
+  return Math.cos(deg * DEG_TO_RAD);
+}
+function computeInvRangeSquared(range) {
+  if (range === Number.POSITIVE_INFINITY) return 0;
+  if (range === 0) return RANGE_ZERO_FALLBACK_INV_R2;
+  return 1 / (range * range);
+}
+function validateDirection(componentName, direction) {
+  const dir = direction;
+  if (dir === void 0 || (dir[0] ?? 0) === 0 && (dir[1] ?? 0) === 0 && (dir[2] ?? 0) === 0) {
+    return new SpawnLightInvalidBoundsError(
+      componentName,
+      "direction",
+      dir === void 0 ? [0, 0, 0] : [dir[0] ?? 0, dir[1] ?? 0, dir[2] ?? 0]
+    );
   }
-  return ok({
-    width,
-    height,
-    halfWidth,
-    halfHeight,
-    bytes: halfWidth * halfHeight * 12 * 2,
-    descriptor,
-    slots,
-    paramsBuffer: params.value,
-    childScope
-  });
+  return null;
 }
-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") {
+function validateDirectionalLightData(data) {
+  const directionError = validateDirection(
+    "DirectionalLight",
+    data.direction
+  );
+  if (directionError !== null) return err(directionError);
+  if (data.castShadow === false) return ok(void 0);
+  const mapSize = data.mapSize ?? 2048;
+  if (mapSize < 1) {
+    return err(new ShadowInvalidConfigError("mapSize", mapSize, 1));
+  }
+  const cascadeCount = data.cascadeCount ?? 4;
+  if (cascadeCount < 1 || cascadeCount > 4 || !Number.isInteger(cascadeCount)) {
+    return err(new ShadowInvalidConfigError("cascadeCount", cascadeCount, 1, 4));
+  }
+  const splitLambda = data.splitLambda ?? 0.75;
+  if (splitLambda < 0 || splitLambda > 1) {
+    return err(new ShadowInvalidConfigError("splitLambda", splitLambda, 0, 1));
+  }
+  const cascadeBlend = data.cascadeBlend ?? 0.2;
+  if (cascadeBlend < 0 || cascadeBlend > 0.5) {
+    return err(new ShadowInvalidConfigError("cascadeBlend", cascadeBlend, 0, 0.5));
+  }
+  const shadowDistance = data.shadowDistance ?? 200;
+  if (shadowDistance <= 0) {
+    return err(new ShadowInvalidConfigError("shadowDistance", shadowDistance, 0, ">"));
+  }
+  const shadowFilter = data.shadowFilter ?? DirectionalShadowFilterValue.pcf3;
+  const allowedFilters = Object.values(DirectionalShadowFilterValue);
+  if (!Number.isFinite(shadowFilter) || !allowedFilters.includes(shadowFilter)) {
+    return err(
+      new ShadowInvalidConfigError(
+        "shadowFilter",
+        shadowFilter,
+        { kind: "allowed-values", values: allowedFilters },
+        void 0,
+        "one of [pcf1, pcf3, pcf5, pcssMedium, pcssHigh]"
+      )
+    );
+  }
+  if (shadowFilter === DirectionalShadowFilterValue.pcssMedium || shadowFilter === DirectionalShadowFilterValue.pcssHigh) {
+    const shadowAngularRadius = data.shadowAngularRadius ?? 465e-5;
+    if (!Number.isFinite(shadowAngularRadius)) {
       return err(
-        failure(
-          "ssr-history-retired",
-          "SSR history resources are active",
-          "recreate the renderer-owned SSR history after device recovery"
-        )
+        new ShadowInvalidConfigError("shadowAngularRadius", shadowAngularRadius, {
+          kind: "range",
+          min: PCSS_RADIUS_MIN,
+          max: PCSS_RADIUS_MAX
+        })
       );
     }
-    if (this.activeCandidate !== void 0) {
+    if (shadowAngularRadius < Math.fround(PCSS_RADIUS_MIN) || shadowAngularRadius > Math.fround(PCSS_RADIUS_MAX)) {
       return err(
-        failure(
-          "ssr-history-active",
-          "one SSR history candidate is active",
-          "commit or abort the active SSR history candidate before beginning another"
-        )
+        new ShadowInvalidConfigError("shadowAngularRadius", shadowAngularRadius, {
+          kind: "range",
+          min: PCSS_RADIUS_MIN,
+          max: PCSS_RADIUS_MAX
+        })
       );
     }
-    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) {
+    const maxPenumbraTexels = data.maxPenumbraTexels ?? 32;
+    if (!Number.isFinite(maxPenumbraTexels) || !Number.isInteger(maxPenumbraTexels) || maxPenumbraTexels < PCSS_PENUMBRA_MIN || maxPenumbraTexels > PCSS_PENUMBRA_MAX) {
       return err(
-        failure(
-          "ssr-history-not-active",
-          "commit the candidate returned by beginFrame",
-          "keep one candidate from beginFrame until the shared queue submit succeeds"
+        new ShadowInvalidConfigError(
+          "maxPenumbraTexels",
+          maxPenumbraTexels,
+          { kind: "range", min: PCSS_PENUMBRA_MIN, max: PCSS_PENUMBRA_MAX },
+          void 0,
+          "a finite integer in [1, 64]"
         )
       );
     }
-    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")
+  return ok(void 0);
+}
+function validateSpotLightData(data) {
+  const directionError = validateDirection(
+    "SpotLight",
+    data.direction
+  );
+  if (directionError !== null) return err(directionError);
+  if (data.castShadow === false) return ok(void 0);
+  const range = data.range ?? 10;
+  if (typeof range !== "number" || Number.isNaN(range) || range < 0) {
+    return err(new SpawnLightInvalidBoundsError("SpotLight", "range", range));
+  }
+  const innerConeDeg = data.innerConeDeg ?? 0;
+  const outerConeDeg = data.outerConeDeg ?? 45;
+  if (outerConeDeg > 90) {
+    return err(new SpawnLightInvalidBoundsError("SpotLight", "outerNinety", outerConeDeg));
+  }
+  if (outerConeDeg <= innerConeDeg) {
+    return err(new SpawnLightInvalidBoundsError("SpotLight", "innerOuter", outerConeDeg));
+  }
+  const mapSize = data.mapSize ?? 2048;
+  if (mapSize < 1) return err(new ShadowInvalidConfigError("mapSize", mapSize, 1));
+  const nearPlane = data.nearPlane;
+  const farPlane = data.farPlane;
+  if (nearPlane !== void 0 && farPlane !== void 0 && farPlane <= nearPlane) {
+    return err(new ShadowInvalidConfigError("farPlane", farPlane, nearPlane));
+  }
+  const pcfKernelSize = data.pcfKernelSize ?? 3;
+  if (pcfKernelSize < 1 || pcfKernelSize % 2 === 0) {
+    return err(
+      new ShadowInvalidConfigError(
+        "pcfKernelSize",
+        pcfKernelSize,
+        { kind: "lower-bound", operator: ">=", value: 1 },
+        void 0,
+        "an odd integer >= 1"
+      )
     );
-    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();
-    });
+  const shadowIntensity = data.shadowIntensity ?? 1;
+  if (!Number.isFinite(shadowIntensity) || shadowIntensity < 0 || shadowIntensity > 1) {
+    return err(new ShadowInvalidConfigError("shadowIntensity", shadowIntensity, 0, 1));
+  }
+  return ok(void 0);
+}
+function validatePointLightData(data) {
+  const range = data.range ?? 10;
+  if (typeof range !== "number" || Number.isNaN(range) || range < 0) {
+    return err(new SpawnLightInvalidBoundsError("PointLight", "range", range));
   }
-  retire() {
-    this.retirementFencePending = false;
-    this.activeCandidate = void 0;
-    if (this.activeResources !== void 0) {
-      this.activeResources.childScope.retire();
-      this.activeResources = void 0;
+  return ok(void 0);
+}
+function validatePointLightShadowData(data) {
+  const mapSize = data.mapSize ?? 512;
+  if (mapSize < 1) return err(new ShadowInvalidConfigError("mapSize", mapSize, 1));
+  const nearPlane = data.nearPlane ?? 0.1;
+  const farPlane = data.farPlane ?? 25;
+  if (farPlane <= nearPlane) {
+    return err(new ShadowInvalidConfigError("farPlane", farPlane, nearPlane));
+  }
+  const pcfKernelSize = data.pcfKernelSize ?? 3;
+  if (pcfKernelSize < 1 || pcfKernelSize % 2 === 0) {
+    return err(
+      new ShadowInvalidConfigError(
+        "pcfKernelSize",
+        pcfKernelSize,
+        { kind: "lower-bound", operator: ">=", value: 1 },
+        void 0,
+        "an odd integer >= 1"
+      )
+    );
+  }
+  return ok(void 0);
+}
+function validateRectAreaLightData(data) {
+  const intensity = data.intensity ?? 1;
+  if (typeof intensity !== "number" || !Number.isFinite(intensity) || intensity < 0) {
+    return err(new SpawnLightInvalidBoundsError("RectAreaLight", "intensity", intensity));
+  }
+  const color = data.color ?? [1, 1, 1];
+  if (color.length !== 3 || Array.from(color).some(
+    (value) => typeof value !== "number" || !Number.isFinite(value) || value < 0
+  )) {
+    return err(new SpawnLightInvalidBoundsError("RectAreaLight", "color", Array.from(color)));
+  }
+  for (const field of ["width", "height", "range"]) {
+    const value = data[field] ?? (field === "range" ? 10 : 1);
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+      return err(new SpawnLightInvalidBoundsError("RectAreaLight", field, value));
     }
-    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);
+  return ok(void 0);
 }
-
-// src/scene/visibility/occlusion-query-pool.ts
-var OCCLUSION_QUERY_PAGE_COUNT = 3;
-var OCCLUSION_QUERY_PAGE_INDEX_LIMIT = 4096;
-var OCCLUSION_QUERY_RESULT_BYTES = 8;
-var OCCLUSION_QUERY_PAGE_BYTES = OCCLUSION_QUERY_PAGE_INDEX_LIMIT * OCCLUSION_QUERY_RESULT_BYTES;
-function identityKey(identity) {
-  return [
-    identity.viewKey,
-    identity.attachmentId,
-    identity.deviceGeneration,
-    identity.worldGeneration,
-    identity.primitiveSlot,
-    identity.slotGeneration
-  ].join("|");
-}
-var OcclusionQueryPool = class {
-  pages = Array.from(
-    { length: OCCLUSION_QUERY_PAGE_COUNT },
-    (_, index) => ({ index, nextQueryIndex: 0, pendingCount: 0, inFlightCount: 0 })
-  );
-  pending = /* @__PURE__ */ new Map();
-  tickets = /* @__PURE__ */ new Map();
-  nextReservationId = 1;
-  disposed = false;
-  reserve(identity) {
-    if (this.disposed) return void 0;
-    const page = this.pages.find(
-      (candidate) => candidate.inFlightCount === 0 && candidate.nextQueryIndex < OCCLUSION_QUERY_PAGE_INDEX_LIMIT
+function validateLightProbeData(data) {
+  const irradiance = data.irradiance;
+  if (irradiance === void 0 || irradiance.length !== 27 || Array.from(irradiance).some((value) => typeof value !== "number" || !Number.isFinite(value))) {
+    return err(
+      new SpawnLightInvalidBoundsError(
+        "LightProbe",
+        "irradiance",
+        irradiance === void 0 ? [] : Array.from(irradiance)
+      )
     );
-    if (page === void 0 || page.nextQueryIndex >= OCCLUSION_QUERY_PAGE_INDEX_LIMIT) {
-      return void 0;
+  }
+  const radius = data.radius ?? R_MIN;
+  if (typeof radius !== "number" || !Number.isFinite(radius) || radius < R_MIN) {
+    return err(new SpawnLightInvalidBoundsError("LightProbe", "radius", radius));
+  }
+  return ok(void 0);
+}
+var LightProbe = defineComponent("LightProbe", {
+  irradiance: { type: "array<f32, 27>" },
+  radius: { type: "f32", default: R_MIN }
+});
+var Lines = defineComponent(
+  "Lines",
+  {
+    widthPx: { type: "f32", default: 1 }
+  },
+  {
+    meta: {
+      quickStart: "Attach Lines to render line-list MeshAsset pairs in screen pixels.",
+      diagnostics: "Inspect widthPx at the points-lines admission boundary.",
+      recovery: "Use points-lines-invalid-style for non-finite or non-positive widthPx values.",
+      boundaries: "Lines owns raster width only; MeshFilter and MeshRenderer own geometry and material."
     }
-    const reservation = Object.freeze({
-      ...identity,
-      pageIndex: page.index,
-      queryIndex: page.nextQueryIndex,
-      reservationId: this.nextReservationId++
-    });
-    page.nextQueryIndex += 1;
-    page.pendingCount += 1;
-    this.pending.set(reservation.reservationId, reservation);
-    return reservation;
-  }
-  publish(reservation, result) {
-    const pending = this.pending.get(reservation.reservationId);
-    if (pending === void 0 || this.disposed) {
+  }
+);
+var MeshFilter = defineComponent("MeshFilter", {
+  assetHandle: { type: "shared<MeshAsset>" }
+});
+var MeshRenderer = defineComponent("MeshRenderer", {
+  materials: { type: "array<shared<MaterialAsset>>", default: [] }
+});
+var MotionBlur = defineComponent("MotionBlur", {
+  shutterAngle: { type: "f32", default: 180 },
+  maxRadiusPixels: { type: "f32", default: 32 },
+  sampleCount: { type: "f32", default: 8 },
+  targetFps: { type: "f32", default: 60 }
+});
+var PointLight = defineComponent("PointLight", {
+  // color carries an explicit layer-2 default [1,1,1] (white); the array
+  // layer-3 fallback is all-zero, so the default MUST be explicit (D-5).
+  color: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  intensity: { type: "f32", default: 1 },
+  range: { type: "f32", default: 10 }
+});
+var PointLightShadow = defineComponent("PointLightShadow", {
+  mapSize: { type: "f32", default: 512 },
+  depthBias: { type: "f32", default: 5e-3 },
+  normalBias: { type: "f32", default: 0.05 },
+  nearPlane: { type: "f32", default: 0.1 },
+  farPlane: { type: "f32", default: 25 },
+  pcfKernelSize: { type: "f32", default: 3 }
+});
+var PointShapeValue = Object.freeze({
+  square: 0,
+  circle: 1
+});
+function pointShapeFromU32(value) {
+  switch (value) {
+    case PointShapeValue.square:
+      return "square";
+    case PointShapeValue.circle:
+      return "circle";
+    default:
       return void 0;
+  }
+}
+var Points = defineComponent(
+  "Points",
+  {
+    sizePx: { type: "f32", default: 4 },
+    shape: { type: "enum", default: PointShapeValue.square, labels: PointShapeValue }
+  },
+  {
+    meta: {
+      quickStart: "Attach Points to render point-list MeshAsset vertices in screen pixels.",
+      diagnostics: "Inspect sizePx and decode shape with pointShapeFromU32.",
+      recovery: "Use points-lines-invalid-style for non-finite or non-positive sizePx values.",
+      boundaries: "Points owns raster size and shape only; MeshFilter and MeshRenderer own geometry and material."
     }
-    if (!result.submitted) return void 0;
-    this.pending.delete(reservation.reservationId);
-    const page = this.pages[pending.pageIndex];
-    if (page !== void 0) {
-      page.pendingCount = Math.max(0, page.pendingCount - 1);
-      page.inFlightCount += 1;
+  }
+);
+var schema = {
+  shader: "string",
+  data: "buffer"
+};
+var PostProcessParams = defineComponent("PostProcessParams", schema);
+var RectAreaLight = defineComponent("RectAreaLight", {
+  color: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  intensity: { type: "f32", default: 1 },
+  width: { type: "f32", default: 1 },
+  height: { type: "f32", default: 1 },
+  range: { type: "f32", default: 10 }
+});
+var REFLECTION_PROBE_UPDATE_ONCE = 0;
+var REFLECTION_PROBE_UPDATE_ON_CHANGE = 1;
+var REFLECTION_PROBE_UPDATE_CONTINUOUS = 2;
+function reflectionProbeUpdateIntentFromF32(value) {
+  switch (value) {
+    case REFLECTION_PROBE_UPDATE_ONCE:
+      return "once";
+    case REFLECTION_PROBE_UPDATE_ON_CHANGE:
+      return "on-change";
+    case REFLECTION_PROBE_UPDATE_CONTINUOUS:
+      return "continuous";
+    default:
+      throw new RenderIntentInvalidError("ReflectionProbe", value);
+  }
+}
+function reflectionProbeUpdateIntentToF32(intent) {
+  switch (intent) {
+    case "once":
+      return REFLECTION_PROBE_UPDATE_ONCE;
+    case "on-change":
+      return REFLECTION_PROBE_UPDATE_ON_CHANGE;
+    case "continuous":
+      return REFLECTION_PROBE_UPDATE_CONTINUOUS;
+  }
+}
+var ReflectionProbe = defineComponent("ReflectionProbe", {
+  halfExtents: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  priority: { type: "f32", default: 0 },
+  boxProjection: { type: "bool", default: false },
+  intensity: { type: "f32", default: 1 },
+  resolution: { type: "u32", default: 256 },
+  updateIntent: { type: "f32", default: REFLECTION_PROBE_UPDATE_ONCE },
+  invalidationVersion: { type: "u32", default: 0 }
+});
+var SceneInstance = defineComponent(
+  "SceneInstance",
+  {
+    source: { type: "shared<SceneAsset>" },
+    mapping: { type: "array<entity>" },
+    // The unique slot is the ECS storage seam for the instance's structured
+    // runtime payload; keep the nested semantic visible to schema consumers.
+    state: { type: "unique<SceneInstanceState>", shape: "nested" }
+  },
+  { transient: true }
+);
+var ScreenSpaceReflection = defineComponent("ScreenSpaceReflection", {
+  maxDistance: { type: "f32", default: 40 },
+  thickness: { type: "f32", default: 0.2 },
+  maxRoughness: { type: "f32", default: 0.6 }
+});
+var SKYBOX_MODE_CUBEMAP = 0;
+var SkyboxBackground = defineComponent("SkyboxBackground", {
+  // The GPU skybox projection is render-owned presentation state; restore
+  // keeps the portable mode/rotation controls and lets the owner re-resolve
+  // the environment asset on the target world.
+  equirect: { type: "shared<EquirectAsset>", simulationTransient: true },
+  mode: { type: "f32", default: SKYBOX_MODE_CUBEMAP },
+  rotation: { type: "array<f32, 4>", default: new Float32Array([0, 0, 0, 1]) }
+});
+var Skylight = defineComponent("Skylight", {
+  // The GPU equirect-to-cubemap projection is render-owned presentation
+  // state. Record/restore preserves the portable lighting controls while the
+  // render owner resolves this asset again on the target world.
+  equirect: { type: "shared<EquirectAsset>", simulationTransient: true },
+  // color carries an explicit layer-2 default [1,1,1] (white); the array
+  // layer-3 fallback is all-zero, so the default MUST be explicit (D-5).
+  color: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  intensity: { type: "f32", default: 1 },
+  rotation: { type: "array<f32, 4>", default: new Float32Array([0, 0, 0, 1]) }
+});
+var SortKey = defineComponent("SortKey", {
+  value: { type: "f32", default: 0 }
+});
+var SpotLight = defineComponent("SpotLight", {
+  // direction has no default (D-5): omitting it lands the array layer-3
+  // all-zero, which validate() rejects. color carries an explicit layer-2
+  // default [1,1,1] (white); the array layer-3 fallback is all-zero.
+  direction: { type: "array<f32, 3>" },
+  color: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  intensity: { type: "f32", default: 1 },
+  range: { type: "f32", default: 10 },
+  innerConeDeg: { type: "f32", default: 0 },
+  outerConeDeg: { type: "f32", default: 45 },
+  iesProfile: { type: "shared<IesProfileAsset>" },
+  cookie: { type: "shared<TextureAsset>" },
+  rollDeg: { type: "f32", default: 0 },
+  // Shadow opt-out gate: defaults to true so zero-config spawns cast shadows.
+  castShadow: { type: "bool", default: true },
+  // 7 shadow fields aligned with the shared light shadow vocabulary.
+  mapSize: { type: "f32", default: 2048 },
+  depthBias: { type: "f32", default: 5e-3 },
+  normalBias: { type: "f32", default: 0.05 },
+  nearPlane: { type: "f32", default: 0.1 },
+  farPlane: { type: "f32", default: 50 },
+  pcfKernelSize: { type: "f32", default: 3 },
+  // Three's SpotLight.shadow.intensity is the fraction of visibility applied
+  // to a shadowed contribution. Keep it in the author-facing [0,1] domain;
+  // extract/record transport this one fact to surface and volume consumers.
+  shadowIntensity: { type: "f32", default: 1 },
+  // Shared TextureAsset identity; publication and residency remain owned by
+  // the existing asset and GPU resource owners.
+  projector: { type: "shared<TextureAsset>", simulationTransient: true }
+});
+var VisibilityStateValue = Object.freeze({
+  inherited: 0,
+  hidden: 1,
+  visible: 2
+});
+function visibilityStateFromU32(value) {
+  switch (value) {
+    case VisibilityStateValue.inherited:
+      return "inherited";
+    case VisibilityStateValue.hidden:
+      return "hidden";
+    case VisibilityStateValue.visible:
+      return "visible";
+    default:
+      return void 0;
+  }
+}
+var Visibility = defineComponent(
+  "Visibility",
+  {
+    state: {
+      type: "enum",
+      default: VisibilityStateValue.inherited,
+      labels: VisibilityStateValue
     }
-    const ticket = Object.freeze({ ...pending, submissionGeneration: result.submissionGeneration });
-    this.tickets.set(ticket.reservationId, ticket);
-    return ticket;
-  }
-  /** Return an unsubmitted reservation to its bounded page. */
-  cancel(reservation) {
-    const pending = this.pending.get(reservation.reservationId);
-    if (pending === void 0) return false;
-    this.pending.delete(reservation.reservationId);
-    const page = this.pages[pending.pageIndex];
-    if (page !== void 0) {
-      page.pendingCount = Math.max(0, page.pendingCount - 1);
-      this.releasePage(pending.pageIndex);
+  },
+  {
+    meta: {
+      quickStart: "Attach Visibility to author render participation intent.",
+      diagnostics: "Compare the ECS state with resolveVisibility and renderer.visibilityStats.",
+      recovery: "Use structured ECS write errors and repair the owning scene relation.",
+      boundaries: "Visibility does not own camera, picking, lifecycle, assets, or VFX shadow policy."
     }
-    return true;
   }
-  complete(ticket, _samples) {
-    const current = this.tickets.get(ticket.reservationId);
-    if (current !== void 0) {
-      this.tickets.delete(ticket.reservationId);
-      const page = this.pages[current.pageIndex];
-      if (page !== void 0) page.inFlightCount = Math.max(0, page.inFlightCount - 1);
-      this.releasePage(current.pageIndex);
+);
+var COMPUTED_UV_BOUNDARY_EPSILON = Number.EPSILON * 16;
+function freezeBarrelDistortionMapping(mapping) {
+  const camera = mapping.camera;
+  return Object.freeze({
+    ...mapping,
+    ...camera === void 0 ? {} : {
+      camera: Object.freeze({
+        projection: camera.projection,
+        far: camera.far,
+        viewMatrix: Object.freeze(Array.from(camera.viewMatrix)),
+        projectionMatrix: Object.freeze(Array.from(camera.projectionMatrix))
+      })
     }
-    if (this.disposed || current === void 0 || identityKey(current) !== identityKey(ticket)) {
-      return { status: "stale", visible: true };
+  });
+}
+function attachBarrelDistortionCameraFrame(mapping, camera) {
+  return freezeBarrelDistortionMapping({
+    ...mapping,
+    camera: {
+      projection: camera.projection,
+      far: camera.far,
+      viewMatrix: camera.viewMatrix,
+      projectionMatrix: camera.projectionMatrix
     }
-    return { status: "accepted", visible: true };
+  });
+}
+function invalidExtent(field, value) {
+  return new BarrelDistortionInvalidParameterError({
+    field,
+    value,
+    expected: "finite and greater than 0"
+  });
+}
+function createBarrelDistortionMapping(width, height, input) {
+  if (!Number.isFinite(width) || width <= 0) return err(invalidExtent("width", width));
+  if (!Number.isFinite(height) || height <= 0) return err(invalidExtent("height", height));
+  const parameters = validateBarrelDistortionParameters(input);
+  if (!parameters.ok) return parameters;
+  const { strength, centerX, centerY } = parameters.value;
+  const aspect = width / height;
+  const radiusSquared = 4 * (aspect * aspect * Math.max(centerX, 1 - centerX) ** 2 + Math.max(centerY, 1 - centerY) ** 2);
+  return ok(
+    Object.freeze({
+      width,
+      height,
+      aspect,
+      strength,
+      centerX,
+      centerY,
+      radiusSquared
+    })
+  );
+}
+function displayToSceneScale(mapping, ux, uy) {
+  const px = 2 * mapping.aspect * (ux - mapping.centerX);
+  const py = 2 * (uy - mapping.centerY);
+  const t = (px * px + py * py) / mapping.radiusSquared;
+  return (1 - mapping.strength) / (1 - mapping.strength * t);
+}
+function normalizeComputedUv(out, x, y) {
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return false;
+  if (x < -COMPUTED_UV_BOUNDARY_EPSILON || x > 1 + COMPUTED_UV_BOUNDARY_EPSILON || y < -COMPUTED_UV_BOUNDARY_EPSILON || y > 1 + COMPUTED_UV_BOUNDARY_EPSILON) {
+    return false;
   }
-  inspect() {
-    return {
-      pageCount: OCCLUSION_QUERY_PAGE_COUNT,
-      pageIndexLimit: OCCLUSION_QUERY_PAGE_INDEX_LIMIT,
-      resolveBytes: OCCLUSION_QUERY_PAGE_BYTES,
-      stagingBytes: OCCLUSION_QUERY_PAGE_BYTES,
-      availablePages: this.disposed ? 0 : this.pages.filter(
-        (page) => page.inFlightCount === 0 && page.nextQueryIndex < OCCLUSION_QUERY_PAGE_INDEX_LIMIT
-      ).length,
-      inFlight: this.tickets.size,
-      disposed: this.disposed
-    };
+  out.x = Math.min(1, Math.max(0, x));
+  out.y = Math.min(1, Math.max(0, y));
+  return true;
+}
+function mapDisplayUvToSceneUv(out, mapping, ux, uy) {
+  if (!Number.isFinite(ux) || !Number.isFinite(uy) || ux < 0 || ux > 1 || uy < 0 || uy > 1)
+    return false;
+  if (mapping.strength === 0) {
+    out.x = ux;
+    out.y = uy;
+    return ux >= 0 && ux <= 1 && uy >= 0 && uy <= 1;
+  }
+  const scale = displayToSceneScale(mapping, ux, uy);
+  return normalizeComputedUv(
+    out,
+    mapping.centerX + (ux - mapping.centerX) * scale,
+    mapping.centerY + (uy - mapping.centerY) * scale
+  );
+}
+function mapSceneUvToDisplayUv(out, mapping, ux, uy) {
+  if (!Number.isFinite(ux) || !Number.isFinite(uy) || ux < 0 || ux > 1 || uy < 0 || uy > 1)
+    return false;
+  if (mapping.strength === 0) {
+    out.x = ux;
+    out.y = uy;
+    return ux >= 0 && ux <= 1 && uy >= 0 && uy <= 1;
+  }
+  const px = 2 * mapping.aspect * (ux - mapping.centerX);
+  const py = 2 * (uy - mapping.centerY);
+  const sourceRadius = Math.hypot(px, py);
+  if (sourceRadius === 0) {
+    out.x = mapping.centerX;
+    out.y = mapping.centerY;
+    return true;
   }
-  dispose() {
-    this.disposed = true;
-    this.pending.clear();
-    this.tickets.clear();
-    for (const page of this.pages) {
-      page.pendingCount = 0;
-      page.inFlightCount = 0;
-    }
+  const discriminant = (1 - mapping.strength) ** 2 + 4 * mapping.strength * sourceRadius * sourceRadius / mapping.radiusSquared;
+  const displayRadius = 2 * sourceRadius / (1 - mapping.strength + Math.sqrt(Math.max(0, discriminant)));
+  const scale = displayRadius / sourceRadius;
+  return normalizeComputedUv(
+    out,
+    mapping.centerX + (ux - mapping.centerX) * scale,
+    mapping.centerY + (uy - mapping.centerY) * scale
+  );
+}
+function validPixel(point) {
+  return Number.isFinite(point.x) && Number.isFinite(point.y);
+}
+function mapDisplayToScene(out, mapping, displayX, displayY) {
+  if (!Number.isFinite(displayX) || !Number.isFinite(displayY)) return false;
+  if (displayX < 0 || displayX > mapping.width || displayY < 0 || displayY > mapping.height) {
+    return false;
   }
-  releasePage(pageIndex) {
-    const page = this.pages[pageIndex];
-    if (page !== void 0 && page.pendingCount === 0 && page.inFlightCount === 0) {
-      page.nextQueryIndex = 0;
-    }
+  const scene = { x: 0, y: 0 };
+  if (!mapDisplayUvToSceneUv(scene, mapping, displayX / mapping.width, displayY / mapping.height)) {
+    return false;
   }
-};
+  out.x = scene.x * mapping.width;
+  out.y = scene.y * mapping.height;
+  return validPixel(out);
+}
+function mapSceneToDisplay(out, mapping, sceneX, sceneY) {
+  if (!Number.isFinite(sceneX) || !Number.isFinite(sceneY)) return false;
+  if (sceneX < 0 || sceneX > mapping.width || sceneY < 0 || sceneY > mapping.height) {
+    return false;
+  }
+  const display = { x: 0, y: 0 };
+  if (!mapSceneUvToDisplayUv(display, mapping, sceneX / mapping.width, sceneY / mapping.height)) {
+    return false;
+  }
+  out.x = display.x * mapping.width;
+  out.y = display.y * mapping.height;
+  return validPixel(out);
+}
 
-// src/scene/visibility/occlusion-pass.ts
-function createOcclusionQueryResources(device, pageIndex) {
-  const querySet = device.createQuerySet({
-    label: `occlusion-page-${pageIndex}`,
-    type: "occlusion",
-    count: OCCLUSION_QUERY_PAGE_INDEX_LIMIT
-  });
-  if (!querySet.ok) return querySet;
-  const resolveBuffer = device.createBuffer({
-    label: `occlusion-page-${pageIndex}-resolve`,
-    size: OCCLUSION_QUERY_PAGE_BYTES,
-    usage: GPU_BUFFER_USAGE_QUERY_RESOLVE | GPU_BUFFER_USAGE_COPY_SRC
-  });
-  if (!resolveBuffer.ok) {
-    device.destroyQuerySet(querySet.value);
-    return resolveBuffer;
-  }
-  const stagingBuffer = device.createBuffer({
-    label: `occlusion-page-${pageIndex}-staging`,
-    size: OCCLUSION_QUERY_PAGE_BYTES,
-    usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST
-  });
-  if (!stagingBuffer.ok) {
-    device.destroyBuffer(resolveBuffer.value);
-    device.destroyQuerySet(querySet.value);
-    return stagingBuffer;
-  }
-  return ok$1({
-    pageIndex,
-    querySet: querySet.value,
-    resolveBuffer: resolveBuffer.value,
-    stagingBuffer: stagingBuffer.value
-  });
+// src/errors/cloud.ts
+var CloudLayerInvalidParameterError = class extends Error {
+  code = "cloud-layer-invalid-parameter";
+  expected;
+  hint;
+  detail;
+  constructor(field, value, expected) {
+    super(`CloudLayer.${field} is invalid`);
+    this.name = "CloudLayerInvalidParameterError";
+    this.expected = `CloudLayer.${field} must be ${expected}`;
+    this.hint = `set CloudLayer.${field} to ${expected}`;
+    this.detail = { field, value, expected };
+  }
+};
+var CloudLayerOwnerConflictError = class extends Error {
+  code = "cloud-layer-owner-conflict";
+  expected = "at most one CloudLayer owns a World frame";
+  hint = "remove additional CloudLayer owners before extraction";
+  detail;
+  constructor(count) {
+    super(`CloudLayer owner cardinality is ${count}`);
+    this.name = "CloudLayerOwnerConflictError";
+    this.detail = { count };
+  }
+};
+var CloudLayerCacheInvalidError = class extends Error {
+  code = "cloud-layer-cache-invalid";
+  expected = "the density cache payload matches its reconstructible source";
+  hint = "discard the derived cache and rebuild it from CloudLayer source facts";
+  detail;
+  constructor(sourceKey, reason) {
+    super(`CloudLayer cache is invalid: ${reason}`);
+    this.name = "CloudLayerCacheInvalidError";
+    this.detail = { sourceKey, reason };
+  }
+};
+var CloudLayerCapabilityMissingError = class extends Error {
+  code = "cloud-layer-capability-missing";
+  expected = "the selected backend exposes the capability required by the cloud lane";
+  hint = "inspect the capability report, disable the cloud lane on this backend, or retry on a backend with the required capability";
+  detail;
+  constructor(capability) {
+    super(`CloudLayer capability is unavailable: ${capability}`);
+    this.name = "CloudLayerCapabilityMissingError";
+    this.detail = { capability };
+  }
+};
+var CloudLayerResourceFailureError = class extends Error {
+  code = "cloud-layer-resource-failed";
+  expected = "cloud resources are created, submitted and retired as one generation";
+  hint = "keep the last-known-good cloud generation and retry after recovery";
+  detail;
+  constructor(detail) {
+    super(`CloudLayer ${detail.stage} resource failed at generation ${detail.generation}`);
+    this.name = "CloudLayerResourceFailureError";
+    this.detail = detail;
+  }
+};
+var CLOUD_QUALITY_PROFILES = Object.freeze({
+  low: Object.freeze({
+    // Preserve low-profile ray counts while keeping separate puffs from
+    // collapsing into one bilinear cache smear.
+    cacheResolution: 32,
+    viewSteps: 40,
+    shadowSteps: 12,
+    historyWeight: 0.82,
+    viewDistance: 1600
+  }),
+  medium: Object.freeze({
+    cacheResolution: 40,
+    viewSteps: 64,
+    shadowSteps: 20,
+    historyWeight: 0.9,
+    viewDistance: 2400
+  }),
+  high: Object.freeze({
+    cacheResolution: 64,
+    viewSteps: 64,
+    shadowSteps: 32,
+    historyWeight: 0.94,
+    viewDistance: 4e3
+  })
+});
+function cloudShadowResolutionForQuality(qualityValue) {
+  return CLOUD_QUALITY_PROFILES[qualityValue].cacheResolution * 4;
+}
+function cloudViewDistanceForQuality(qualityValue) {
+  return CLOUD_QUALITY_PROFILES[qualityValue].viewDistance;
+}
+var CLOUD_EXTINCTION_COEFFICIENT = 0.03;
+var DEFAULT_CLOUD_LAYER = Object.freeze({
+  seed: 1337,
+  baseHeight: 120,
+  thickness: 80,
+  scale: 4e-3,
+  coverage: 0.48,
+  density: 1,
+  wind: Object.freeze([8, 0, 2]),
+  quality: "medium",
+  shadowRange: 512
+});
+function invalid3(field, value, expected) {
+  return err(new CloudLayerInvalidParameterError(field, value, expected));
 }
-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$1(
-      new RhiError({
-        code: "webgpu-runtime-error",
-        expected: "query range stays within one 4096-index page",
-        hint: "allocate a bounded page before recording occlusion resolve"
-      })
-    );
+function finiteRange(field, value, min, max = Number.POSITIVE_INFINITY) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+    const expected = Number.isFinite(max) ? `finite and in [${min}, ${max}]` : `finite and >= ${min}`;
+    return invalid3(field, value, expected);
   }
-  const resolved = encoder.resolveQuerySet(
-    resources.querySet,
-    firstQuery,
-    queryCount,
-    resources.resolveBuffer,
-    0
+  return ok(value);
+}
+function quality(value) {
+  if (typeof value === "string" && (value === "low" || value === "medium" || value === "high")) {
+    return ok(value);
+  }
+  if (typeof value === "number") {
+    const resolved = cloudQualityFromF32(value);
+    if (resolved !== void 0) return ok(resolved);
+  }
+  return invalid3(
+    "quality",
+    value,
+    `one of low, medium, high (codes ${CloudQualityValue.low}, ${CloudQualityValue.medium}, ${CloudQualityValue.high})`
+  );
+}
+function wind(value) {
+  if (value === void 0 || value === null || typeof value !== "object") {
+    return invalid3("wind", value, "three finite world-space components");
+  }
+  const source = value;
+  if (source.length !== 3) return invalid3("wind", value, "three finite world-space components");
+  const result = [
+    source[0] ?? Number.NaN,
+    source[1] ?? Number.NaN,
+    source[2] ?? Number.NaN
+  ];
+  if (result.some((entry) => !Number.isFinite(entry) || Math.abs(entry) > 1e3)) {
+    return invalid3("wind", value, "three finite components in [-1000, 1000]");
+  }
+  return ok(Object.freeze(result));
+}
+function validateCloudLayer(input) {
+  const value = input ?? {};
+  const seed = value.seed ?? DEFAULT_CLOUD_LAYER.seed;
+  if (typeof seed !== "number" || !Number.isInteger(seed) || seed < 0 || seed > 4294967295) {
+    return invalid3("seed", seed, "an integer in [0, 4294967295]");
+  }
+  const baseHeight = finiteRange(
+    "baseHeight",
+    value.baseHeight ?? DEFAULT_CLOUD_LAYER.baseHeight,
+    -1e5,
+    1e6
+  );
+  if (!baseHeight.ok) return baseHeight;
+  const thickness = finiteRange(
+    "thickness",
+    value.thickness ?? DEFAULT_CLOUD_LAYER.thickness,
+    1e-3,
+    1e6
+  );
+  if (!thickness.ok) return thickness;
+  const scale = finiteRange("scale", value.scale ?? DEFAULT_CLOUD_LAYER.scale, 1e-6, 10);
+  if (!scale.ok) return scale;
+  const coverage = finiteRange("coverage", value.coverage ?? DEFAULT_CLOUD_LAYER.coverage, 0, 1);
+  if (!coverage.ok) return coverage;
+  const density = finiteRange("density", value.density ?? DEFAULT_CLOUD_LAYER.density, 0, 32);
+  if (!density.ok) return density;
+  const resolvedWind = wind(value.wind ?? DEFAULT_CLOUD_LAYER.wind);
+  if (!resolvedWind.ok) return resolvedWind;
+  const resolvedQuality = quality(value.quality ?? DEFAULT_CLOUD_LAYER.quality);
+  if (!resolvedQuality.ok) return resolvedQuality;
+  const shadowRange = finiteRange(
+    "shadowRange",
+    value.shadowRange ?? DEFAULT_CLOUD_LAYER.shadowRange,
+    1e-3,
+    1e7
   );
-  if (!resolved.ok) return resolved;
-  encoder.copyBufferToBuffer(resources.resolveBuffer, resources.stagingBuffer, queryCount * 8);
-  return ok$1(void 0);
+  if (!shadowRange.ok) return shadowRange;
+  return ok(
+    Object.freeze({
+      seed,
+      baseHeight: baseHeight.value,
+      thickness: thickness.value,
+      scale: scale.value,
+      coverage: coverage.value,
+      density: density.value,
+      wind: resolvedWind.value,
+      quality: resolvedQuality.value,
+      shadowRange: shadowRange.value
+    })
+  );
+}
+function cloudLayerSourceKey(params) {
+  return [
+    "cloud-layer-v1",
+    params.seed,
+    params.baseHeight,
+    params.thickness,
+    params.scale,
+    params.coverage,
+    params.density,
+    params.wind[0],
+    params.wind[1],
+    params.wind[2],
+    params.quality,
+    params.shadowRange
+  ].join(":");
+}
+function cloudLayerFormationKey(params) {
+  return [
+    "cloud-formation-v5",
+    params.seed,
+    params.baseHeight,
+    params.thickness,
+    params.scale,
+    params.quality
+  ].join(":");
+}
+var MAX_VOLUMETRIC_FOG_OWNERS = 8;
+var VolumetricFogSamplingValue = { noise: 0, density: 1 };
+var VolumetricFog = defineComponent("VolumetricFog", {
+  light: { type: "entity" },
+  spotLight: { type: "entity" },
+  density: { type: "shared<TextureAsset>", simulationTransient: true },
+  boundsMin: { type: "array<f32, 3>" },
+  boundsMax: { type: "array<f32, 3>" },
+  extinction: { type: "array<f32, 3>" },
+  albedo: { type: "array<f32, 3>" },
+  emission: { type: "array<f32, 3>" },
+  anisotropy: { type: "f32", default: 0 },
+  maxDistance: { type: "f32", default: 100 },
+  sampling: { type: "enum", labels: VolumetricFogSamplingValue, default: 0 }
+});
+function finiteVector(value) {
+  return value.every(Number.isFinite);
+}
+function validBounds(bounds) {
+  if (!finiteVector(bounds.min) || !finiteVector(bounds.max)) return false;
+  return bounds.max.every((value, index) => value > (bounds.min[index] ?? value));
+}
+function validRange(value, min, max = Infinity) {
+  return value.every((entry) => Number.isFinite(entry) && entry >= min && entry <= max);
+}
+function validateVolumetricFog(input) {
+  if (input.density.shape.viewDimension !== "3d" || input.density.colorSpace === "srgb") {
+    return err(
+      new VolumeDensityShapeMismatchError(input.density.guid, input.density.shape.viewDimension)
+    );
+  }
+  if (!validBounds(input.bounds)) return err(new VolumeInvalidBoundsError(input.bounds));
+  if (!validRange(input.extinction, 0) || !validRange(input.albedo, 0, 1) || !validRange(input.emission, 0) || !Number.isFinite(input.anisotropy) || input.anisotropy <= -1 || input.anisotropy >= 1 || !Number.isFinite(input.maxDistance) || input.maxDistance <= 0 || input.sampling !== void 0 && input.sampling !== "noise" && input.sampling !== "density") {
+    return err(new VolumeInvalidParametersError(input));
+  }
+  return ok(input);
 }
 
-// src/scene/visibility/types.ts
-function viewKeyId(key) {
-  return `${key.attachmentId}:${key.cameraEntity}:${key.viewRole}:${key.viewGeneration}`;
+// src/environment/signature.ts
+function sorted(items) {
+  return [...items].sort((left, right) => left.entityKey - right.entityKey);
+}
+function environmentSignature(input) {
+  return JSON.stringify({
+    environments: sorted(input.environments),
+    fogs: sorted(input.fogs),
+    suns: sorted(input.suns)
+  });
 }
-function primitiveKeyId(key) {
-  return `${key.attachmentId}:${key.worldGeneration}:${key.primitiveSlot}:${key.slotGeneration}`;
+function environmentOnlySignature(input) {
+  return JSON.stringify({
+    environments: sorted(input.environments),
+    suns: sorted(input.suns)
+  });
 }
-function viewKey(input) {
-  return Object.freeze({ ...input });
+function fogOnlySignature(input) {
+  return JSON.stringify({ fogs: sorted(input.fogs) });
 }
-function primitiveKey(input) {
-  return Object.freeze({ ...input });
+function environmentFactSignatures(input) {
+  return {
+    environmentSignature: environmentOnlySignature(input),
+    fogSignature: fogOnlySignature(input),
+    signature: environmentSignature(input)
+  };
 }
 
-// src/scene/visibility/occlusion-runtime.ts
-var PROXY_VERTEX_FLOATS_PER_CANDIDATE = 36 * 4;
-var PROXY_GEOMETRY_BYTES = OCCLUSION_QUERY_PAGE_INDEX_LIMIT * PROXY_VERTEX_FLOATS_PER_CANDIDATE * 4;
-var runtimeTestHooks;
-function setOcclusionRuntimeTestHooks(hooks) {
-  runtimeTestHooks = hooks;
-}
-var OcclusionRenderRuntime = class {
-  constructor(device, facets, shaderModuleFactory, budget = facets.visibilityBudget()) {
-    this.device = device;
-    this.facets = facets;
-    this.shaderModuleFactory = shaderModuleFactory;
-    this.budget = budget;
-    const runtime = this;
-    this.proxyScratch = new Float32Array(
-      Math.min(this.budget.effectiveQueryBudget, OCCLUSION_QUERY_PAGE_INDEX_LIMIT) * PROXY_VERTEX_FLOATS_PER_CANDIDATE
-    );
-    this.projection = {
-      get querySet() {
-        return runtime.pendingFrame?.resources.querySet;
-      },
-      get queryIndex() {
-        return runtime.pendingFrame?.reservations[0]?.queryIndex ?? 0;
-      },
-      get queryCount() {
-        return runtime.pendingFrame?.reservations.length ?? 0;
-      },
-      get sampleCount() {
-        return runtime.pendingFrame?.sampleCount ?? 1;
-      },
-      get pageIndex() {
-        return runtime.pendingFrame?.reservations[0]?.pageIndex ?? 0;
-      },
-      get reservationId() {
-        return runtime.pendingFrame?.reservations[0]?.reservationId ?? 0;
-      },
-      encodeProxyBounds: (pass) => {
-        const pending = runtime.pendingFrame;
-        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$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$1(runtimeError("the current RenderSystem frame owns the occlusion candidate"));
-        }
-        const ended = pass.endOcclusionQuery();
-        if (ended.ok) pending.endedCount += 1;
-        return ended;
-      },
-      recordResolve: (encoder) => {
-        const pending = runtime.pendingFrame;
-        if (pending === void 0 || pending.endedCount !== pending.reservations.length) {
-          return err$1(runtimeError("the real geometry pass must end its occlusion query first"));
-        }
-        return recordOcclusionResolve(
-          encoder,
-          pending.resources,
-          pending.reservations[0]?.queryIndex ?? 0,
-          pending.reservations.length
-        );
-      },
-      commit: (submitted, submissionGeneration, profilePhase) => {
-        const pending = runtime.pendingFrame;
-        if (pending !== void 0)
-          runtime.commit(pending, submitted, submissionGeneration, profilePhase);
-      }
+// src/extract/environment.ts
+var ATMOSPHERE_PARAMETER_RANGES = Object.freeze({
+  turbidity: Object.freeze({ min: 1, max: 20 }),
+  rayleigh: Object.freeze({ min: 0, max: Number.POSITIVE_INFINITY }),
+  mieCoefficient: Object.freeze({ min: 0, max: Number.POSITIVE_INFINITY }),
+  mieDirectionalG: Object.freeze({ min: 0, max: 0.999 }),
+  sunAngularRadius: Object.freeze({ min: 0, max: Number.POSITIVE_INFINITY }),
+  circumsolarStrength: Object.freeze({ min: 0, max: 4 }),
+  circumsolarWidth: Object.freeze({ min: 0.25, max: 4 })
+});
+function validateFogParameters(candidate) {
+  if (candidate.color.length !== 3) {
+    return {
+      field: "color",
+      value: candidate.color.length,
+      expected: "exactly three finite channels in [0, 1]"
     };
   }
-  device;
-  facets;
-  shaderModuleFactory;
-  budget;
-  pool = new OcclusionQueryPool();
-  resources = /* @__PURE__ */ new Map();
-  activeCompletions = /* @__PURE__ */ new Map();
-  retiredResources = /* @__PURE__ */ new Set();
-  /** Candidate descriptors are rebuilt only when the extracted frame changes. */
-  candidateSource;
-  validCandidates = [];
-  candidateByKey = /* @__PURE__ */ new Map();
-  lastPrepareUnavailable = false;
-  pendingFrame;
-  disposed = false;
-  proxyBuffer;
-  proxyScratch;
-  proxyPipeline;
-  proxyPipelineSampleCount;
-  queryLatencySamplesUs = [];
-  lastQueryLatencyUs = 0;
-  projection;
-  prepare(candidate) {
-    return this.prepareBatch([candidate], 1, false);
-  }
-  prepareBatch(candidates, sampleCount = 1, useReadyQueue = true) {
-    this.lastPrepareUnavailable = false;
-    if (this.disposed || candidates.length === 0) return void 0;
-    if (this.pendingFrame !== void 0) {
-      this.lastPrepareUnavailable = true;
-      return void 0;
+  for (let index = 0; index < candidate.color.length; index += 1) {
+    const value = candidate.color[index];
+    if (value === void 0 || !Number.isFinite(value) || value < 0 || value > 1) {
+      return {
+        field: `color[${index}]`,
+        value: value ?? Number.NaN,
+        expected: "a finite number in [0, 1]"
+      };
     }
-    if (this.candidateSource !== candidates) {
-      this.candidateSource = candidates;
-      this.candidateByKey.clear();
-      const valid2 = [];
-      for (const candidate of candidates) {
-        this.candidateByKey.set(candidateKey(candidate.view, candidate.primitive), candidate);
-        if (finiteBounds(candidate.bounds)) valid2.push(candidate);
-      }
-      this.validCandidates = valid2;
+  }
+  if (!Number.isFinite(candidate.density) || candidate.density < 0) {
+    return { field: "density", value: candidate.density, expected: "a finite number >= 0" };
+  }
+  if (!Number.isFinite(candidate.heightFalloff) || candidate.heightFalloff < 0) {
+    return {
+      field: "heightFalloff",
+      value: candidate.heightFalloff,
+      expected: "a finite number >= 0"
+    };
+  }
+  if (!Number.isFinite(candidate.maxOpacity) || candidate.maxOpacity < 0 || candidate.maxOpacity > 1) {
+    return {
+      field: "maxOpacity",
+      value: candidate.maxOpacity,
+      expected: "a finite number in [0, 1]"
+    };
+  }
+  return void 0;
+}
+function validateAtmosphereParameters(parameters) {
+  for (const field of Object.keys(ATMOSPHERE_PARAMETER_RANGES)) {
+    const value = parameters[field];
+    const range = ATMOSPHERE_PARAMETER_RANGES[field];
+    if (!Number.isFinite(value) || value < range.min || value > range.max) {
+      return new AtmosphereInvalidParameterError(field, value, range);
     }
-    const valid = this.validCandidates;
-    if (valid.length === 0) return void 0;
-    let selectedCandidates;
-    if (!useReadyQueue) {
-      selectedCandidates = valid.slice(0, this.budget.effectiveQueryBudget);
-    } else {
-      const firstView = valid[0]?.view;
-      if (firstView === void 0) return void 0;
-      selectedCandidates = [];
-      for (const entry of this.facets.dequeueQueryCandidates(
-        firstView,
-        this.budget.effectiveQueryBudget
-      )) {
-        const candidate = this.candidateByKey.get(candidateKey(entry.view, entry.primitive));
-        if (candidate === void 0 || !finiteBounds(candidate.bounds)) {
-          this.facets.requeueQueryCandidate(entry.view, entry.primitive);
-          continue;
-        }
-        selectedCandidates.push(candidate);
-      }
-      if (selectedCandidates.length === 0) return void 0;
+  }
+  return void 0;
+}
+
+// src/environment/frame.ts
+var SKYLIGHT_RECOVERY_FALLBACK = Object.freeze({
+  kind: "skylight",
+  active: false
+});
+var EnvironmentSelectionParameterError = class extends Error {
+  code = "environment-selection-invalid";
+  expected;
+  hint;
+  detail;
+  constructor(field, value, expected) {
+    super(`environment selection field ${field} is invalid`);
+    this.name = "EnvironmentSelectionParameterError";
+    this.expected = expected;
+    this.hint = `set ${field} to a finite value satisfying ${expected}`;
+    this.detail = { field, value };
+  }
+};
+var SunCardinalityError = class extends Error {
+  code = "sun-cardinality";
+  expected = "atmosphere has exactly one sun owner";
+  hint = "add exactly one DirectionalLight sun for the atmosphere owner";
+  detail;
+  constructor(value) {
+    super(`atmosphere sun cardinality is ${value}`);
+    this.name = "SunCardinalityError";
+    this.detail = { field: "sun", value };
+  }
+};
+function freezeCandidate(candidate) {
+  return Object.freeze(candidate);
+}
+function freezeFog(candidate) {
+  return Object.freeze({
+    ...candidate,
+    color: Object.freeze([...candidate.color])
+  });
+}
+function selectEnvironment(input) {
+  if (input.environments.length > 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(new FogCardinalityError(input.fogs.length));
+  const selectedFog = input.fogs[0];
+  if (selectedFog !== void 0) {
+    const issue = validateFogParameters(selectedFog);
+    if (issue !== void 0) {
+      return err(new EnvironmentSelectionParameterError(issue.field, issue.value, issue.expected));
     }
-    const reservations = [];
-    let selectedCount = 0;
-    while (selectedCount < selectedCandidates.length) {
-      const candidate = selectedCandidates[selectedCount];
-      if (candidate === void 0) break;
-      const reservation = this.pool.reserve({
-        viewKey: viewKeyId(candidate.view),
-        attachmentId: candidate.view.attachmentId,
-        deviceGeneration: candidate.deviceGeneration,
-        worldGeneration: candidate.primitive.worldGeneration,
-        primitiveSlot: candidate.primitive.primitiveSlot,
-        slotGeneration: candidate.primitive.slotGeneration
-      });
-      if (reservation === void 0) {
-        this.lastPrepareUnavailable = true;
-        break;
-      }
-      if (reservations.length > 0 && reservation.pageIndex !== reservations[0]?.pageIndex) {
-        this.pool.cancel(reservation);
-        this.lastPrepareUnavailable = true;
-        break;
-      }
-      reservations.push(reservation);
-      selectedCount += 1;
-      if (reservations.length >= this.budget.effectiveQueryBudget) break;
+  }
+  const selected = input.environments[0];
+  if (selected?.kind === "atmosphere") {
+    const invalid5 = validateAtmosphereParameters(selected.atmosphere);
+    if (invalid5 !== void 0) return err(invalid5);
+  }
+  if (selected?.kind === "atmosphere" && input.suns.length !== 1) {
+    return err(new SunCardinalityError(input.suns.length));
+  }
+  const source = selected === void 0 ? { kind: "none" } : selected.kind === "atmosphere" ? {
+    kind: "atmosphere",
+    entityKey: selected.entityKey,
+    sourceKey: selected.sourceKey,
+    atmosphere: Object.freeze({ ...selected.atmosphere })
+  } : {
+    kind: "image",
+    entityKey: selected.entityKey,
+    sourceKey: selected.sourceKey
+  };
+  const sun = input.suns[0] === void 0 ? void 0 : freezeCandidate({ ...input.suns[0] });
+  const fog = selectedFog === void 0 ? void 0 : freezeFog(selectedFog);
+  const signatureInput = {
+    environments: selected === void 0 ? [] : [selected],
+    fogs: selectedFog === void 0 ? [] : [selectedFog],
+    suns: input.suns
+  };
+  const signatures = environmentFactSignatures(signatureInput);
+  const result = {
+    source: Object.freeze(source),
+    fog,
+    ...signatures,
+    revision: 0,
+    sun
+  };
+  Object.defineProperty(result, "lane", { value: input.lane, enumerable: false });
+  return ok(Object.freeze(result));
+}
+var DEPTH_OF_FIELD_PARAMS_BYTE_SIZE = 64;
+var MIN_F_STOP = Math.fround(0.7);
+var MAX_F_STOP = Math.fround(32);
+var MAX_LINEAR_DEPTH_RAW = Math.fround(1 - 2 ** -24);
+var DEFAULT_DEPTH_OF_FIELD_PARAMS = Object.freeze({
+  focusDistance: 8,
+  fStop: 2.8,
+  sensorHeight: 0.024,
+  maxRadiusPixels: 16,
+  quality: "medium",
+  blurSide: "both",
+  focalLength: 0
+});
+function quantizeF32(value) {
+  return Math.fround(value);
+}
+var DepthOfFieldValidationError = class extends Error {
+  code;
+  expected;
+  hint;
+  detail;
+  constructor(code, detail, expected, hint) {
+    super(`${code}: ${expected}`);
+    this.name = "DepthOfFieldValidationError";
+    this.code = code;
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = detail;
+  }
+};
+function depthOfFieldRequestFailure(error) {
+  return Object.freeze({
+    code: error.code,
+    detail: error.detail,
+    expected: error.expected,
+    hint: error.hint
+  });
+}
+function resolveDepthOfFieldFrameParams(requested, requestFailure, accepted) {
+  if (requested !== void 0) return requested;
+  if (requestFailure === void 0 || requestFailure.code === "depth-of-field-orthographic-unsupported") {
+    return void 0;
+  }
+  return accepted;
+}
+function invalid4(field, value, expected, bound) {
+  return new DepthOfFieldValidationError(
+    "depth-of-field-invalid-params",
+    { field, value, expected, ...bound === void 0 ? {} : { bound } },
+    expected,
+    `set ${field} to ${expected}`
+  );
+}
+function focalLength(sensorHeight, fov) {
+  return sensorHeight / (2 * Math.tan(fov / 2));
+}
+function opticalCocScale(params) {
+  return params.focalLength / params.sensorHeight / (2 * params.fStop) * (params.focalLength / (params.focusDistance - params.focalLength));
+}
+function frameCocCoefficient(params, outputHeight) {
+  return quantizeF32(quantizeF32(outputHeight) * opticalCocScale(params));
+}
+function resolveDepthOfFieldFrameValues(params, input) {
+  const focusDistance = quantizeF32(params.focusDistance);
+  const fStop = quantizeF32(params.fStop);
+  const sensorHeight = quantizeF32(params.sensorHeight);
+  const focal = quantizeF32(params.focalLength);
+  const maxRadiusPixels = quantizeF32(params.maxRadiusPixels);
+  const outputHeight = quantizeF32(input.outputHeight);
+  const near = quantizeF32(input.near);
+  const far = quantizeF32(input.far);
+  const finitePositiveFields = [
+    ["focusDistance", focusDistance, params.focusDistance],
+    ["sensorHeight", sensorHeight, params.sensorHeight],
+    ["focalLength", focal, params.focalLength],
+    ["near", near, input.near],
+    ["far", far, input.far]
+  ];
+  for (const [field, value, raw] of finitePositiveFields) {
+    if (!Number.isFinite(value) || value <= 0) {
+      return err(invalid4(field, raw, "a finite positive f32 value"));
     }
-    if (reservations.length === 0) {
-      for (const candidate of selectedCandidates) {
-        if (useReadyQueue) this.facets.requeueQueryCandidate(candidate.view, candidate.primitive);
-      }
-      return void 0;
+  }
+  if (!Number.isFinite(fStop) || fStop < MIN_F_STOP || fStop > MAX_F_STOP) {
+    return err(
+      invalid4("fStop", params.fStop, "a finite f32 value in [0.7, 32]", [MIN_F_STOP, MAX_F_STOP])
+    );
+  }
+  if (!Number.isFinite(maxRadiusPixels) || maxRadiusPixels < 0 || maxRadiusPixels > 32) {
+    return err(
+      invalid4("maxRadiusPixels", params.maxRadiusPixels, "a finite f32 value in [0, 32]", [0, 32])
+    );
+  }
+  if (!Number.isFinite(outputHeight) || outputHeight <= 0) {
+    return err(invalid4("outputHeight", input.outputHeight, "a finite positive f32 value"));
+  }
+  if (far <= near) {
+    return err(invalid4("near/far", [input.near, input.far], "finite f32 near > 0 and far > near"));
+  }
+  if (focusDistance <= focal) {
+    return err(invalid4("focusDistance", params.focusDistance, "greater than focalLength in f32"));
+  }
+  const depthRatio = quantizeF32(near / far);
+  if (!Number.isFinite(depthRatio) || depthRatio <= 0) {
+    return err(invalid4("near/far ratio", depthRatio, "a finite positive f32 value"));
+  }
+  for (const raw of [quantizeF32(2 ** -149), 0.5, MAX_LINEAR_DEPTH_RAW]) {
+    const oneMinusRaw = quantizeF32(1 - raw);
+    const weightedRatio = quantizeF32(raw * depthRatio);
+    const denominator = quantizeF32(oneMinusRaw + weightedRatio);
+    const distance = quantizeF32(near / denominator);
+    if (!Number.isFinite(oneMinusRaw) || oneMinusRaw <= 0 || !Number.isFinite(weightedRatio) || !Number.isFinite(denominator) || denominator <= 0 || !Number.isFinite(distance) || distance <= 0) {
+      return err(invalid4("linearDepth", distance, "finite positive f32 reconstruction"));
     }
-    if (reservations.length < selectedCandidates.length) {
-      for (const reservation of reservations) this.pool.cancel(reservation);
-      for (const candidate of selectedCandidates) {
-        if (useReadyQueue) this.facets.requeueQueryCandidate(candidate.view, candidate.primitive);
-      }
-      return void 0;
+  }
+  const cocCoefficient = frameCocCoefficient(
+    {
+      focusDistance,
+      fStop,
+      sensorHeight,
+      focalLength: focal
+    },
+    outputHeight
+  );
+  if (!Number.isFinite(cocCoefficient) || cocCoefficient <= 0) {
+    return err(
+      invalid4("cocCoefficient", cocCoefficient, "a finite positive value representable as f32")
+    );
+  }
+  for (const [field, depth] of [
+    ["near", near],
+    ["far", far]
+  ]) {
+    const focusOverDepth = quantizeF32(focusDistance / depth);
+    const depthFactor = quantizeF32(1 - focusOverDepth);
+    const radius = quantizeF32(cocCoefficient * depthFactor);
+    if (!Number.isFinite(focusOverDepth) || !Number.isFinite(depthFactor) || !Number.isFinite(radius)) {
+      return err(invalid4(`coc.${field}`, radius, "a finite value representable as f32"));
     }
-    const resources = this.ensureResources(reservations[0]?.pageIndex ?? 0);
-    if (resources === void 0) {
-      for (const reservation of reservations) this.pool.cancel(reservation);
-      this.lastPrepareUnavailable = true;
-      for (const candidate of selectedCandidates) {
-        if (useReadyQueue) this.facets.requeueQueryCandidate(candidate.view, candidate.primitive);
-      }
-      return void 0;
+  }
+  return ok({
+    focusDistance,
+    fStop,
+    sensorHeight,
+    focalLength: focal,
+    maxRadiusPixels,
+    outputHeight,
+    near,
+    far,
+    cocCoefficient
+  });
+}
+function validateDepthOfFieldFrameParams(params, input) {
+  const resolved = resolveDepthOfFieldFrameValues(params, input);
+  return resolved.ok ? ok(void 0) : resolved;
+}
+function validateDepthOfFieldParams(input, camera) {
+  if (camera?.projection === "orthographic") {
+    return err(
+      new DepthOfFieldValidationError(
+        "depth-of-field-orthographic-unsupported",
+        { projection: "orthographic" },
+        "DepthOfField requires a perspective Camera",
+        "use a perspective Camera or remove the DepthOfField component"
+      )
+    );
+  }
+  const value = input ?? {};
+  const focusDistance = quantizeF32(
+    value.focusDistance ?? DEFAULT_DEPTH_OF_FIELD_PARAMS.focusDistance
+  );
+  const fStop = quantizeF32(value.fStop ?? DEFAULT_DEPTH_OF_FIELD_PARAMS.fStop);
+  const sensorHeight = quantizeF32(
+    value.sensorHeight ?? DEFAULT_DEPTH_OF_FIELD_PARAMS.sensorHeight
+  );
+  const maxRadiusPixels = quantizeF32(
+    value.maxRadiusPixels ?? DEFAULT_DEPTH_OF_FIELD_PARAMS.maxRadiusPixels
+  );
+  const qualityValue = quantizeF32(value.quality ?? DepthOfFieldQualityValue.medium);
+  const blurSideValue = quantizeF32(value.blurSide ?? DepthOfFieldSideValue.both);
+  const quality2 = depthOfFieldQualityFromF32(qualityValue);
+  const blurSide = depthOfFieldSideFromF32(blurSideValue);
+  if (!Number.isFinite(focusDistance) || focusDistance <= 0) {
+    return err(
+      invalid4("focusDistance", value.focusDistance ?? focusDistance, "a finite positive f32 value")
+    );
+  }
+  if (!Number.isFinite(fStop) || fStop < MIN_F_STOP || fStop > MAX_F_STOP) {
+    return err(
+      invalid4("fStop", value.fStop ?? fStop, "a finite f32 value in [0.7, 32]", [
+        MIN_F_STOP,
+        MAX_F_STOP
+      ])
+    );
+  }
+  if (!Number.isFinite(sensorHeight) || sensorHeight <= 0) {
+    return err(
+      invalid4("sensorHeight", value.sensorHeight ?? sensorHeight, "a finite positive f32 value")
+    );
+  }
+  if (!Number.isFinite(maxRadiusPixels) || maxRadiusPixels < 0 || maxRadiusPixels > 32) {
+    return err(
+      invalid4(
+        "maxRadiusPixels",
+        value.maxRadiusPixels ?? maxRadiusPixels,
+        "a finite f32 value in [0, 32]",
+        [0, 32]
+      )
+    );
+  }
+  if (quality2 === void 0) {
+    return err(invalid4("quality", qualityValue, "DepthOfFieldQualityValue.low, medium, or high"));
+  }
+  if (blurSide === void 0) {
+    return err(invalid4("blurSide", blurSideValue, "DepthOfFieldSideValue.both, near, or far"));
+  }
+  let focal = DEFAULT_DEPTH_OF_FIELD_PARAMS.focalLength;
+  if (camera !== void 0) {
+    const fov = quantizeF32(camera.fov);
+    const near = quantizeF32(camera.near);
+    const far = quantizeF32(camera.far);
+    if (!Number.isFinite(fov) || fov <= 0 || fov >= Math.PI) {
+      return err(invalid4("fov", camera.fov, "a finite f32 value in (0, PI)"));
     }
-    const selected = selectedCandidates;
-    let proxyFloatCount = 0;
-    for (const candidate of selected) {
-      const vertices = candidate.proxyVertices;
-      if (vertices === void 0) continue;
-      if (proxyFloatCount + vertices.length > this.proxyScratch.length) {
-        for (const reservation of reservations) this.pool.cancel(reservation);
-        for (const queuedCandidate of selectedCandidates) {
-          if (useReadyQueue) {
-            this.facets.requeueQueryCandidate(queuedCandidate.view, queuedCandidate.primitive);
-          }
-        }
-        this.lastPrepareUnavailable = true;
-        return void 0;
-      }
-      this.proxyScratch.set(vertices, proxyFloatCount);
-      proxyFloatCount += vertices.length;
+    if (!Number.isFinite(near) || !Number.isFinite(far) || near <= 0 || far <= near) {
+      return err(
+        invalid4("near/far", [camera.near, camera.far], "finite f32 near > 0 and far > near")
+      );
+    }
+    focal = quantizeF32(focalLength(sensorHeight, fov));
+    if (!Number.isFinite(focal) || focal <= 0) {
+      return err(invalid4("focalLength", focal, "a finite positive f32 value"));
+    }
+    if (focusDistance < near || focusDistance > far) {
+      return err(
+        invalid4("focusDistance", focusDistance, `a value in [${near}, ${far}]`, [near, far])
+      );
+    }
+    if (focusDistance <= focal) {
+      return err(
+        invalid4("focusDistance", focusDistance, `greater than focalLength in f32 (${focal})`)
+      );
     }
-    const pending = {
-      reservations,
-      resources,
-      candidates: selected,
-      sampleCount,
-      endedCount: 0,
-      proxyFloatCount
+  }
+  return ok(
+    Object.freeze({
+      focusDistance,
+      fStop,
+      sensorHeight,
+      maxRadiusPixels,
+      quality: quality2,
+      blurSide,
+      focalLength: focal
+    })
+  );
+}
+function resolveDepthOfFieldParams(input, camera) {
+  if (input === void 0) return ok(void 0);
+  return validateDepthOfFieldParams(input, camera);
+}
+function depthOfFieldTapCount(quality2) {
+  switch (quality2) {
+    case "low":
+      return 16;
+    case "medium":
+      return 32;
+    case "high":
+      return 64;
+  }
+}
+function depthOfFieldSideCode(side) {
+  switch (side) {
+    case "both":
+      return DepthOfFieldSideValue.both;
+    case "near":
+      return DepthOfFieldSideValue.near;
+    case "far":
+      return DepthOfFieldSideValue.far;
+  }
+}
+function depthOfFieldQualityCode(quality2) {
+  switch (quality2) {
+    case "low":
+      return DepthOfFieldQualityValue.low;
+    case "medium":
+      return DepthOfFieldQualityValue.medium;
+    case "high":
+      return DepthOfFieldQualityValue.high;
+  }
+}
+function signedDepthOfFieldCoC(params, viewDepth, outputHeight) {
+  if (!Number.isFinite(viewDepth) || viewDepth <= 0 || !Number.isFinite(outputHeight) || outputHeight <= 0 || !Number.isFinite(params.focalLength) || params.focalLength <= 0 || !Number.isFinite(params.sensorHeight) || params.sensorHeight <= 0 || !Number.isFinite(params.fStop) || params.fStop <= 0 || !Number.isFinite(params.focusDistance) || params.focusDistance <= params.focalLength) {
+    return 0;
+  }
+  const focusDistance = quantizeF32(params.focusDistance);
+  const depth = quantizeF32(viewDepth);
+  const focalLength2 = quantizeF32(params.focalLength);
+  const sensorHeight = quantizeF32(params.sensorHeight);
+  const fStop = quantizeF32(params.fStop);
+  const coefficient = frameCocCoefficient(
+    { focusDistance, focalLength: focalLength2, sensorHeight, fStop },
+    outputHeight
+  );
+  const depthFactor = quantizeF32(1 - quantizeF32(focusDistance / depth));
+  const radius = quantizeF32(coefficient * depthFactor);
+  const limit = Number.isFinite(params.maxRadiusPixels) ? quantizeF32(params.maxRadiusPixels) : Number.POSITIVE_INFINITY;
+  return Math.max(-limit, Math.min(limit, Number.isFinite(radius) ? radius : 0));
+}
+function packDepthOfFieldParams(params, input) {
+  const frameValues = resolveDepthOfFieldFrameValues(params, input);
+  if (!frameValues.ok) throw frameValues.error;
+  const {
+    focusDistance,
+    fStop,
+    sensorHeight,
+    focalLength: focal,
+    outputHeight,
+    maxRadiusPixels,
+    near,
+    far,
+    cocCoefficient
+  } = frameValues.value;
+  const payload = new Float32Array(DEPTH_OF_FIELD_PARAMS_BYTE_SIZE / 4);
+  payload.set([
+    focusDistance,
+    fStop,
+    sensorHeight,
+    focal,
+    outputHeight,
+    maxRadiusPixels,
+    depthOfFieldSideCode(params.blurSide),
+    depthOfFieldQualityCode(params.quality),
+    near,
+    far,
+    input.useTemporalDepth ? 1 : 0,
+    0,
+    // row2.w reserved
+    cocCoefficient,
+    // row3.x / WGSL reserved.x
+    0,
+    0,
+    0
+  ]);
+  return new Uint8Array(payload.buffer);
+}
+function hasVolumetricFogCapability(caps, shaders) {
+  return caps.compute && caps.storageTexture && shaders !== void 0;
+}
+function resolveVolumetricFogLightPair(world, point, spot) {
+  const expected = "PointLight + SpotLight in the same World";
+  if (!world.get(point, Entity).ok || !world.get(spot, Entity).ok) {
+    return {
+      status: "unresolved",
+      reason: "missing-entity",
+      point,
+      spot,
+      expected,
+      actual: "point or spot entity is absent from this World",
+      hint: "assign two live entities from the same World and retry"
+    };
+  }
+  if (point === spot) {
+    return {
+      status: "unresolved",
+      reason: "same-entity",
+      point,
+      spot,
+      expected,
+      actual: "PointLight and SpotLight share one EntityHandle",
+      hint: "spawn PointLight and SpotLight on two different entities"
     };
-    this.pendingFrame = pending;
-    return this.projection;
   }
-  inspect() {
-    return this.pool.inspect();
+  const pointValid = world.hasComponent(point, PointLight) && world.hasComponent(point, Transform);
+  const spotValid = world.hasComponent(spot, SpotLight) && world.hasComponent(spot, Transform);
+  if (!pointValid || !spotValid) {
+    return {
+      status: "unresolved",
+      reason: "wrong-component",
+      point,
+      spot,
+      expected,
+      actual: `pointValid=${pointValid}; spotValid=${spotValid}`,
+      hint: "attach PointLight and SpotLight with Transform to separate same-World entities"
+    };
   }
-  get prepareUnavailable() {
-    return this.lastPrepareUnavailable;
+  return { status: "available", mode: "point-spot", point, spot };
+}
+function resolveSelectedVolumetricLight(world, entity) {
+  const expected = "DirectionalLight | PointLight | SpotLight";
+  if (!world.get(entity, Entity).ok) {
+    return {
+      status: "unresolved",
+      reason: "missing-entity",
+      entity,
+      expected,
+      actual: "missing or foreign World entity",
+      hint: "assign VolumetricFog.light to a live DirectionalLight or SpotLight in this World"
+    };
   }
-  /** Map-only latency from the submitted query page; queue wait is excluded. */
-  inspectQueryLatency() {
-    if (this.queryLatencySamplesUs.length === 0) {
-      return { median: 0, p95: 0, last: this.lastQueryLatencyUs };
-    }
-    const sorted = [...this.queryLatencySamplesUs].sort((left, right) => left - right);
-    const rank = (percentile) => sorted[Math.max(0, Math.ceil(sorted.length * percentile) - 1)] ?? 0;
+  const hasDirectional = world.hasComponent(entity, DirectionalLight);
+  const hasSpot = world.hasComponent(entity, SpotLight);
+  if (hasDirectional && hasSpot) {
     return {
-      median: rank(0.5),
-      p95: rank(0.95),
-      last: this.lastQueryLatencyUs
+      status: "unresolved",
+      reason: "ambiguous",
+      entity,
+      expected,
+      actual: "DirectionalLight + SpotLight",
+      hint: "remove one mutually exclusive light component from the selected entity"
     };
   }
-  /**
-   * Wait until query readbacks submitted before the current observation have
-   * settled. The renderer receipt only fences command submission; query
-   * completion also includes the asynchronous map/unmap transition. Keeping
-   * that fence here makes `renderer.observe()` publish the latest visibility
-   * result and measured map latency instead of racing the readback promise.
-   */
-  async waitForCompletions() {
-    for (; ; ) {
-      const completions = [...this.activeCompletions.values()];
-      if (completions.length === 0) return;
-      await Promise.all(completions);
-    }
+  if (hasDirectional) return { status: "available", entity, kind: "directional" };
+  if (world.hasComponent(entity, PointLight) && world.hasComponent(entity, Transform)) {
+    return { status: "available", entity, kind: "point" };
   }
-  /** Count a successful frame for hidden rows that were not queried this frame. */
-  advanceSuccessfulSubmit(submissionGeneration) {
-    this.facets.advanceSuccessfulSubmits(submissionGeneration);
-  }
-  dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.pool.dispose();
-    for (const resource of this.resources.values()) {
-      const completion = this.activeCompletions.get(resource);
-      if (completion === void 0) {
-        this.destroyResources(resource);
-      } else {
-        void completion.then(() => this.destroyResources(resource));
+  if (hasSpot && world.hasComponent(entity, Transform)) {
+    return { status: "available", entity, kind: "spot" };
+  }
+  const actual = hasSpot ? "SpotLight without Transform" : world.hasComponent(entity, PointLight) ? "PointLight" : "other component";
+  return {
+    status: "unresolved",
+    reason: "wrong-component",
+    entity,
+    expected,
+    actual,
+    hint: "add exactly one supported light component and a Transform for PointLight or SpotLight in the same World"
+  };
+}
+function resolveIntegratedVolumeConsumer(resource, consumer) {
+  return { consumer, resource };
+}
+var FACE_ORIENTATION = [
+  { direction: [1, 0, 0], up: [0, 1, 0] },
+  { direction: [-1, 0, 0], up: [0, 1, 0] },
+  { direction: [0, 1, 0], up: [0, 0, -1] },
+  { direction: [0, -1, 0], up: [0, 0, 1] },
+  { direction: [0, 0, 1], up: [0, 1, 0] },
+  { direction: [0, 0, -1], up: [0, 1, 0] }
+];
+function assertRange(near, far) {
+  if (!Number.isFinite(near) || near <= 0 || !Number.isFinite(far) || far <= near) {
+    throw new RangeError("CubeCamera requires finite near > 0 and far > near.");
+  }
+}
+function buildCubeCameraFaceViews(input) {
+  assertRange(input.near, input.far);
+  const views = [];
+  for (const [index, face] of CUBE_CAMERA_FACE_ORDER.entries()) {
+    const orientation = FACE_ORIENTATION[index];
+    if (orientation === void 0)
+      throw new Error(`CubeCamera face orientation missing at ${index}`);
+    const target = [
+      (input.position[0] ?? 0) + orientation.direction[0],
+      (input.position[1] ?? 0) + orientation.direction[1],
+      (input.position[2] ?? 0) + orientation.direction[2]
+    ];
+    const view = mat4.lookAt(mat4.create(), input.position, target, orientation.up);
+    const projection = mat4.perspective(mat4.create(), Math.PI / 2, 1, input.near, input.far);
+    const viewProjection = mat4.multiply(mat4.create(), projection, view);
+    views.push({
+      position: input.position,
+      face,
+      direction: orientation.direction,
+      up: orientation.up,
+      near: input.near,
+      far: input.far,
+      view,
+      projection,
+      viewProjection
+    });
+  }
+  return views;
+}
+
+// src/mesh-material-bindings.ts
+var EMPTY_RESIDENCY = Object.freeze({
+  readiness: "pending",
+  samplers: Object.freeze([]),
+  textures: Object.freeze([])
+});
+function projectMeshMaterialBindingObservation(input) {
+  const residency = input.bindings.map((_, index) => {
+    const value = input.residency?.[index] ?? EMPTY_RESIDENCY;
+    return Object.freeze({
+      ...value,
+      samplers: Object.freeze(value.samplers.map((sampler) => Object.freeze({ ...sampler }))),
+      textures: Object.freeze(value.textures.map((texture) => Object.freeze({ ...texture }))),
+      ...value.preparationFailure === void 0 ? {} : {
+        preparationFailure: Object.freeze({
+          ...value.preparationFailure,
+          ...value.preparationFailure.detail === void 0 ? {} : { detail: Object.freeze({ ...value.preparationFailure.detail }) }
+        })
       }
-    }
-    this.resources.clear();
-    if (this.proxyBuffer !== void 0) this.device.destroyBuffer(this.proxyBuffer);
-    this.proxyBuffer = void 0;
-    this.proxyPipeline = void 0;
-    this.proxyPipelineSampleCount = void 0;
-    this.candidateSource = void 0;
-    this.validCandidates = [];
-    this.candidateByKey.clear();
-    this.lastPrepareUnavailable = false;
-    this.pendingFrame = void 0;
-  }
-  ensureResources(pageIndex) {
-    const existing = this.resources.get(pageIndex);
-    if (existing !== void 0) return existing;
-    const created = createOcclusionQueryResources(this.device, pageIndex);
-    if (!created.ok) return void 0;
-    this.resources.set(pageIndex, created.value);
-    return created.value;
-  }
-  commit(pending, submitted, submissionGeneration, profilePhase) {
-    if (this.pendingFrame !== pending) return;
-    this.pendingFrame = void 0;
-    const tickets = [];
-    const accepted = profilePhase === void 0 ? this.publishAndApplySubmit(pending, submitted, submissionGeneration, tickets) : profilePhase(
-      "record/occlusion-query-submit",
-      () => this.publishAndApplySubmit(pending, submitted, submissionGeneration, tickets)
-    );
-    if (!accepted) {
-      for (const reservation of pending.reservations) this.pool.cancel(reservation);
-      for (const candidate of pending.candidates) {
-        this.facets.applyConfidence(candidate.view, candidate.primitive, {
-          type: "failure",
-          submissionGeneration
-        });
+    });
+  });
+  return {
+    worldId: input.worldId,
+    ...input.worldIdentity === void 0 ? {} : { worldIdentity: input.worldIdentity },
+    entityKey: input.entityKey,
+    bindings: Object.freeze([...input.bindings]),
+    diagnostics: Object.freeze([...input.diagnostics]),
+    residency: Object.freeze(residency)
+  };
+}
+function summarizeMeshMaterialBindings(observations) {
+  let ready = 0;
+  let pending = 0;
+  let failed = 0;
+  let lastKnownGood = 0;
+  let textureCount = 0;
+  let samplerCount = 0;
+  for (const observation of observations) {
+    for (const residency of observation.residency) {
+      switch (residency.readiness) {
+        case "ready":
+          ready += 1;
+          break;
+        case "pending":
+          pending += 1;
+          break;
+        case "failed":
+          failed += 1;
+          break;
+        case "last-known-good":
+          lastKnownGood += 1;
+          break;
       }
-      return;
+      textureCount += residency.textures.length;
+      samplerCount += residency.samplers.length;
     }
-    if (profilePhase === void 0) {
-      this.facets.advanceSuccessfulSubmits(submissionGeneration);
-    } else {
-      profilePhase(
-        "record/occlusion-global-advance",
-        () => this.facets.advanceSuccessfulSubmits(submissionGeneration)
-      );
-    }
-    const completion = this.completeAfterSubmit(tickets, pending);
-    this.activeCompletions.set(pending.resources, completion);
-    void completion.then(() => {
-      if (this.activeCompletions.get(pending.resources) === completion) {
-        this.activeCompletions.delete(pending.resources);
-      }
+  }
+  return {
+    total: ready + pending + failed + lastKnownGood,
+    ready,
+    pending,
+    failed,
+    lastKnownGood,
+    textureCount,
+    samplerCount
+  };
+}
+function resolveMeshMaterialBindings(mesh, rendererOverrides, deps) {
+  const bindings = [];
+  const diagnostics = [];
+  if (!Array.isArray(mesh.materialSlots)) {
+    return { ok: false, code: "mesh-material-slots-missing" };
+  }
+  if (rendererOverrides.length > mesh.materialSlots.length) {
+    diagnostics.push({
+      code: "mesh-renderer-material-override-overflow",
+      slotIndex: mesh.materialSlots.length
     });
   }
-  publishAndApplySubmit(pending, submitted, submissionGeneration, tickets) {
-    for (const reservation of pending.reservations) {
-      const ticket = this.pool.publish(reservation, { submitted, submissionGeneration });
-      if (ticket !== void 0) tickets.push(ticket);
+  for (let slotIndex = 0; slotIndex < mesh.materialSlots.length; slotIndex++) {
+    const override = rendererOverrides[slotIndex] ?? 0;
+    if (override !== 0 && deps.isValidOverride(override)) {
+      bindings.push({ handle: override, source: "renderer-override" });
+      continue;
     }
-    if (!submitted || tickets.length !== pending.reservations.length) return false;
-    const submitEvent = Object.freeze({ type: "submit", submissionGeneration });
-    for (const candidate of pending.candidates) {
-      this.facets.applyConfidence(candidate.view, candidate.primitive, submitEvent);
+    if (override !== 0) {
+      diagnostics.push({
+        code: "mesh-renderer-material-override-invalid",
+        slotIndex,
+        handle: override
+      });
     }
-    return true;
-  }
-  destroyResources(resource) {
-    if (this.retiredResources.has(resource)) return;
-    this.retiredResources.add(resource);
-    this.device.destroyBuffer(resource.resolveBuffer);
-    this.device.destroyBuffer(resource.stagingBuffer);
-    this.device.destroyQuerySet(resource.querySet);
-  }
-  async completeAfterSubmit(tickets, pending) {
-    try {
-      await this.device.queue.onSubmittedWorkDone();
-      const mapStart = performance.now();
-      await runtimeTestHooks?.beforeMap?.();
-      const mapped = await pending.resources.stagingBuffer.mapAsync(
-        GPU_BUFFER_USAGE_MAP_READ,
-        0,
-        pending.reservations.length * 8
-      );
-      if (!mapped.ok) throw mapped.error;
-      this.lastQueryLatencyUs = Math.max(0, Math.round((performance.now() - mapStart) * 1e3));
-      this.queryLatencySamplesUs.push(this.lastQueryLatencyUs);
-      if (this.queryLatencySamplesUs.length > 64) this.queryLatencySamplesUs.shift();
-      const bytes = mapped.value.getMappedRange(0, pending.reservations.length * 8);
-      if (!bytes.ok) throw bytes.error;
-      const data = new Uint8Array(bytes.value.slice(0));
-      const dataView = new DataView(data.buffer);
-      const firstQuery = pending.reservations[0]?.queryIndex ?? 0;
-      mapped.value.unmap();
-      for (let ticketIndex = tickets.length - 1; ticketIndex >= 0; ticketIndex -= 1) {
-        const ticket = tickets[ticketIndex];
-        if (ticket === void 0) continue;
-        const candidateIndex = ticket.queryIndex - firstQuery;
-        const samples = dataView.getUint32(candidateIndex * 8, true);
-        const completion = this.pool.complete(ticket, samples);
-        if (completion.status !== "accepted") continue;
-        const candidate = pending.candidates[candidateIndex];
-        if (candidate === void 0) continue;
-        this.facets.applyConfidence(candidate.view, candidate.primitive, {
-          type: "result",
-          samples,
-          submissionGeneration: ticket.submissionGeneration
-        });
-        this.facets.applyCompletion(
-          candidate.view,
-          candidate.primitive,
-          candidate.epoch,
-          candidate.candidate
-        );
-      }
-    } catch {
-      for (const ticket of tickets) {
-        this.pool.complete(ticket, Number.NaN);
-        const candidate = pending.candidates[ticket.queryIndex - (pending.reservations[0]?.queryIndex ?? 0)];
-        if (candidate !== void 0) {
-          this.facets.applyConfidence(candidate.view, candidate.primitive, {
-            type: "failure",
-            submissionGeneration: ticket.submissionGeneration
-          });
-        }
+    const declaredDefault = mesh.materialSlots[slotIndex]?.defaultMaterial;
+    if (declaredDefault !== void 0) {
+      const handle = deps.resolveMeshDefault(declaredDefault);
+      if (handle === void 0) {
+        return {
+          ok: false,
+          code: "mesh-default-material-not-ready",
+          slotIndex,
+          defaultMaterial: declaredDefault
+        };
       }
+      bindings.push({ handle, source: "mesh-default" });
+      continue;
     }
-  }
-  encodeProxyBounds(pass, pending) {
-    if (pending.proxyFloatCount === 0) {
-      return err$1(runtimeError("every occlusion candidate needs conservative proxy geometry"));
-    }
-    const pipeline = this.ensureProxyPipeline(pending.sampleCount);
-    if (pipeline === void 0) {
-      for (const reservation of pending.reservations) {
-        const began = pass.beginOcclusionQuery(reservation.queryIndex);
-        if (!began.ok) return began;
-        const ended = pass.endOcclusionQuery();
-        if (!ended.ok) return ended;
+    bindings.push({ handle: 0, source: "engine-default" });
+  }
+  return { ok: true, bindings, diagnostics };
+}
+function resolveVisibility(world, hierarchy = projectHierarchy(world)) {
+  const query = world.query({ read: [Visibility] });
+  const visitVisibilityRows = (visit) => {
+    if (!query.ok) return;
+    const spans = query.value.spans();
+    if (spans.ok) {
+      for (const span of spans.value) {
+        const states = span.get(Visibility).state;
+        for (let index = 0; index < span.length; index += 1) {
+          visit(span.entities[index], states[index] ?? 0);
+        }
       }
-      pending.endedCount = pending.reservations.length;
-      return ok$1(void 0);
+      return;
     }
-    const buffer = this.ensureProxyBuffer(pending.proxyFloatCount * Float32Array.BYTES_PER_ELEMENT);
-    if (buffer === void 0) {
-      return err$1(runtimeError("the backend must allocate the bounded proxy geometry buffer"));
+    for (const row of query.value) {
+      visit(row.entity, row.get(Visibility).state);
     }
-    const uploaded = this.device.queue.writeBuffer(
-      buffer,
-      0,
-      this.proxyScratch.subarray(0, pending.proxyFloatCount)
-    );
-    if (!uploaded.ok) return uploaded;
-    pass.setPipeline(pipeline);
-    pass.setVertexBuffer(0, buffer);
-    let vertexOffset = 0;
-    for (let index = 0; index < pending.reservations.length; index += 1) {
-      const vertices = pending.candidates[index]?.proxyVertices;
-      if (vertices === void 0 || vertices.length === 0) continue;
-      const began = pass.beginOcclusionQuery(pending.reservations[index]?.queryIndex ?? 0);
-      if (!began.ok) return began;
-      pass.draw(vertices.length / 4, 1, vertexOffset / 4, 0);
-      const ended = pass.endOcclusionQuery();
-      if (!ended.ok) return ended;
-      vertexOffset += vertices.length;
+  };
+  let intentCount = 0;
+  let hasAnyHiddenIntent = false;
+  visitVisibilityRows((_entity, rawState) => {
+    intentCount += 1;
+    if (rawState === VisibilityStateValue.hidden) {
+      hasAnyHiddenIntent = true;
     }
-    pending.endedCount = pending.reservations.length;
-    return ok$1(void 0);
-  }
-  ensureProxyBuffer(byteLength) {
-    if (this.proxyBuffer !== void 0) return this.proxyBuffer;
-    const created = this.device.createBuffer({
-      label: "occlusion-bounds-proxy-geometry",
-      size: Math.max(16, PROXY_GEOMETRY_BYTES, byteLength),
-      usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST
+  });
+  let resolveEntity;
+  let hasIntent;
+  const ensureResolver = () => {
+    if (resolveEntity !== void 0) return;
+    const intentByEntity = /* @__PURE__ */ new Map();
+    visitVisibilityRows((entity, rawState) => {
+      const intent = visibilityStateFromU32(rawState);
+      if (intent !== void 0) {
+        intentByEntity.set(entity, intent);
+      }
     });
-    if (!created.ok) return void 0;
-    this.proxyBuffer = created.value;
-    return created.value;
+    hasIntent = (entity) => intentByEntity.has(entity);
+    const resolved = /* @__PURE__ */ new Map();
+    const resolving = /* @__PURE__ */ new Set();
+    resolveEntity = (entity) => {
+      const existing = resolved.get(entity);
+      if (existing !== void 0) return existing;
+      if (resolving.has(entity)) return void 0;
+      const intent = intentByEntity.get(entity) ?? "inherited";
+      resolving.add(entity);
+      let result;
+      if (intent === "hidden") {
+        result = { intent, effective: "hidden", source: "self" };
+      } else if (intent === "visible") {
+        result = { intent, effective: "visible", source: "self" };
+      } else {
+        const parent = hierarchy.getParent(entity);
+        const parentResult = parent === void 0 ? void 0 : resolveEntity?.(parent);
+        result = parentResult === void 0 ? { intent, effective: "visible", source: "default" } : { intent, effective: parentResult.effective, source: "parent" };
+      }
+      resolving.delete(entity);
+      resolved.set(entity, result);
+      return result;
+    };
+  };
+  const snapshot = {
+    diagnostics: hierarchy.diagnostics,
+    hasAnyIntent: intentCount > 0,
+    hasAnyHiddenIntent,
+    get(entity) {
+      ensureResolver();
+      return hasIntent?.(entity) ? resolveEntity?.(entity) : void 0;
+    },
+    effective(entity) {
+      ensureResolver();
+      return resolveEntity?.(entity)?.effective ?? "visible";
+    }
+  };
+  return snapshot;
+}
+function selectCloudLayerFrame(candidates, worldTimeSeconds = 0, sunDirection = void 0, sunRadiance = void 0) {
+  if (candidates.length === 0) return ok(void 0);
+  if (candidates.length > 1) return err(new CloudLayerOwnerConflictError(candidates.length));
+  const candidate = candidates[0];
+  if (candidate === void 0) return ok(void 0);
+  const validated = validateCloudLayer(candidate.data);
+  if (!validated.ok) return validated;
+  return ok(
+    Object.freeze({
+      status: "available",
+      entityKey: candidate.entityKey,
+      sourceKey: cloudLayerSourceKey(validated.value),
+      params: validated.value,
+      worldTimeSeconds: Number.isFinite(worldTimeSeconds) ? Math.max(0, worldTimeSeconds) : 0,
+      sunDirection: sunDirection === void 0 ? void 0 : Object.freeze([...sunDirection]),
+      sunRadiance: sunRadiance === void 0 ? void 0 : Object.freeze([...sunRadiance]),
+      revision: 1
+    })
+  );
+}
+function extractCloudLayer(world) {
+  const candidates = [];
+  try {
+    const query = world.query({ read: [CloudLayer] });
+    if (!query.ok) return ok(void 0);
+    for (const row of query.value)
+      candidates.push({ entityKey: row.entity, data: row.get(CloudLayer) });
+  } catch {
+    return ok(void 0);
   }
-  ensureProxyPipeline(sampleCount) {
-    if (this.proxyPipelineSampleCount === sampleCount && this.proxyPipeline !== void 0) {
-      return this.proxyPipeline;
+  let sunDirection;
+  let sunRadiance;
+  try {
+    const query = world.query({ read: [DirectionalLight] });
+    if (query.ok) {
+      for (const row of query.value) {
+        const light = row.get(DirectionalLight);
+        const intensity = Number.isFinite(light.intensity) ? Math.max(0, light.intensity) : 0;
+        sunDirection = [
+          -(light.direction[0] ?? 0),
+          -(light.direction[1] ?? -1),
+          -(light.direction[2] ?? 0)
+        ];
+        sunRadiance = [
+          (light.color[0] ?? 1) * intensity,
+          (light.color[1] ?? 1) * intensity,
+          (light.color[2] ?? 1) * intensity
+        ];
+        break;
+      }
     }
-    if (this.shaderModuleFactory === void 0) return void 0;
-    const module = this.shaderModuleFactory.createShaderModule({
-      label: "occlusion-bounds-proxy",
-      code: PROXY_BOUNDS_WGSL
-    });
-    if (!module.ok) return void 0;
-    const created = this.device.createRenderPipeline({
-      label: "occlusion-bounds-proxy",
-      layout: "auto",
-      vertex: {
-        module: module.value,
-        entryPoint: "vs_main",
-        buffers: [
-          {
-            arrayStride: 16,
-            stepMode: "vertex",
-            attributes: [{ shaderLocation: 0, offset: 0, format: "float32x4" }]
-          }
-        ]
-      },
-      // The proxy is recorded in the typed main pass, whose color attachment
-      // remains RGBA16Float. Keep the pass compatible while suppressing all
-      // color writes; occlusion only consumes depth samples.
-      fragment: {
-        module: module.value,
-        entryPoint: "fs_main",
-        targets: [{ format: "rgba16float", writeMask: 0 }]
-      },
-      primitive: { topology: "triangle-list" },
-      depthStencil: {
-        format: "depth24plus-stencil8",
-        depthWriteEnabled: false,
-        depthCompare: "less-equal"
-      },
-      multisample: { count: sampleCount }
-    });
-    if (!created.ok) return void 0;
-    this.proxyPipeline = created.value;
-    this.proxyPipelineSampleCount = sampleCount;
-    return created.value;
+  } catch {
   }
-};
-var PROXY_BOUNDS_WGSL = `
-@vertex
-fn vs_main(@location(0) position: vec4f) -> @builtin(position) vec4f {
-  return position;
-}
-@fragment
-fn fs_main() -> @location(0) vec4f {
-  return vec4f(0.0);
-}
-`;
-function candidateKey(view, primitive) {
-  return `${viewKeyId(view)}|${primitiveKeyId(primitive)}`;
-}
-function finiteBounds(bounds) {
-  return [...bounds.min, ...bounds.max].every((value) => Number.isFinite(value));
-}
-function runtimeError(hint) {
-  return new RhiError({
-    code: "webgpu-runtime-error",
-    expected: "RenderSystem owns one active occlusion candidate for the shared frame",
-    hint
-  });
+  return selectCloudLayerFrame(
+    candidates,
+    world.getResource(Time).elapsed,
+    sunDirection,
+    sunRadiance
+  );
+}
+function extractVolumetricFog(inputs) {
+  if (inputs.length === 0) return ok({ status: "off" });
+  if (inputs.length > MAX_VOLUMETRIC_FOG_OWNERS)
+    return err(new VolumeOwnerConflictError(inputs.length));
+  const fogs = [];
+  for (const input of inputs) {
+    const validated = validateVolumetricFog(input);
+    if (!validated.ok) return validated;
+    fogs.push(validated.value);
+  }
+  return ok({ status: "available", fogs });
 }
 
 // src/extract/directional-shadow-projection.ts
@@ -1514,224 +2651,6 @@ 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;
-  for (let index = 0; index < values.length; index += 1) {
-    fingerprintScalar[0] = Number(values[index]);
-    hash = Math.imul(hash ^ (fingerprintBits[0] ?? 0), 16777619) >>> 0;
-  }
-  return hash >>> 0;
-}
-function finiteAabb(aabb) {
-  if (aabb === void 0 || aabb.length < 6) return false;
-  const minX = aabb[0];
-  const minY = aabb[1];
-  const minZ = aabb[2];
-  const maxX = aabb[3];
-  const maxY = aabb[4];
-  const maxZ = aabb[5];
-  return Number.isFinite(minX) && Number.isFinite(minY) && Number.isFinite(minZ) && Number.isFinite(maxX) && Number.isFinite(maxY) && Number.isFinite(maxZ) && minX <= maxX && minY <= maxY && minZ <= maxZ;
-}
-function finiteMatrix(matrix) {
-  if (matrix.length < 16) return false;
-  for (let index = 0; index < 16; index += 1) {
-    if (!Number.isFinite(matrix[index])) return false;
-  }
-  return true;
-}
-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;
-  if (!finiteAabb(meshAabb) || !finiteMatrix(entityWorld) || transforms === void 0) {
-    return void 0;
-  }
-  if (transforms.length === 0 || transforms.length % 16 !== 0) return void 0;
-  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) {
-    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 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 },
-      entityKey: input.entityKey,
-      meshGeneration: input.meshGeneration,
-      transformGeneration: input.transformGeneration,
-      matrixGeneration: input.matrixGeneration,
-      bounds
-    });
-    return bounds;
-  }
-  invalidate(entityKey, worldId) {
-    if (entityKey === void 0) {
-      if (this.entries.size > 0) this.invalidations += this.entries.size;
-      this.entries.clear();
-    } else {
-      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
 function expandPointsLinesBounds(bounds, style) {
   if (bounds.length < 6 || style === void 0) return new Float32Array(bounds);
@@ -1909,10 +2828,10 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
       });
       const frame = extractFrame(world, prepared);
       framesByWorld.set(wi, frame);
-    } catch (err5) {
-      if (err5 instanceof MotionBlurValidationError) throw err5;
+    } catch (err13) {
+      if (err13 instanceof MotionBlurValidationError) throw err13;
       try {
-        createWorldInternalView(world)._routeError(err5, {
+        createWorldInternalView(world)._routeError(err13, {
           severity: Severity.Error,
           systemName: `RenderSystem.extractFrames(world[${wi}])`
         });
@@ -3144,30 +4063,32 @@ function extractFrame(world, context) {
           if (asset.kind !== "material") {
             materialSnap = defaultMaterialSnapshot(handleRaw);
           } else {
+            const source = world.sharedRefs.resolve(tagged);
+            const programOwner = source.ok && source.value.kind === "material" ? source.value : asset;
             const resolvedResult = walkMaterialPassesOverSharedRefs(world, tagged, assets);
             if (!resolvedResult.ok) {
-              const err5 = resolvedResult.error;
-              switch (err5.code) {
+              const err13 = resolvedResult.error;
+              switch (err13.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(err5, {
+                  worldInternal._routeError(err13, {
                     severity: Severity.Error,
-                    systemName: `RenderSystem.extract (${err5.code})`
+                    systemName: `RenderSystem.extract (${err13.code})`
                   });
                   break;
                 case "material-circular-inheritance":
-                  worldInternal._routeError(err5, {
+                  worldInternal._routeError(err13, {
                     severity: Severity.Error,
                     systemName: "RenderSystem.extract (material-circular-inheritance)"
                   });
                   break;
                 default:
-                  worldInternal._routeError(err5, {
+                  worldInternal._routeError(err13, {
                     severity: Severity.Error,
-                    systemName: `RenderSystem.extract (_materialWalk: ${err5.code})`
+                    systemName: `RenderSystem.extract (_materialWalk: ${err13.code})`
                   });
               }
               continue;
@@ -3180,17 +4101,21 @@ function extractFrame(world, context) {
             };
             try {
               materialProgramSelections = materialProgramSelectionsForMaterial(
-                asset,
+                programOwner,
                 assets,
                 materialContext
               );
             } catch (error) {
               if (isMissingMaterialProgram(error) && materialContext?.geometry === "mesh") {
                 try {
-                  const skinnedSelections = materialProgramSelectionsForMaterial(asset, assets, {
-                    ...materialContext,
-                    geometry: "skinned"
-                  });
+                  const skinnedSelections = materialProgramSelectionsForMaterial(
+                    programOwner,
+                    assets,
+                    {
+                      ...materialContext,
+                      geometry: "skinned"
+                    }
+                  );
                   if (skinnedSelections?.some(materialProgramSelectionRequiresSkin) === true && gpuDrivenMesh !== void 0) {
                     const hasSkinIndex = gpuDrivenMesh.attributes.skinIndex !== void 0;
                     const hasSkinWeight = gpuDrivenMesh.attributes.skinWeight !== void 0;
@@ -3215,7 +4140,7 @@ function extractFrame(world, context) {
               ])
             );
             const materialSceneIndexProgramKeys = materialSceneIndexProgramKeysForMaterial(
-              asset,
+              programOwner,
               assets,
               materialContext
             );
@@ -3539,6 +4464,7 @@ function extractFrame(world, context) {
       }
       if (isRenderable) {
         let skinSlice;
+        let skinPose;
         const skinIdentity = hasSkin ? skinPaletteIdentity(world, entity) : void 0;
         const releaseSkinIdentity = () => {
           if (skinIdentity !== void 0) {
@@ -3624,10 +4550,19 @@ function extractFrame(world, context) {
               });
               skinPaletteAllocator.writePersistentJointPalette(receipt, ibms, jointWorlds);
               skinSlice = receipt;
+            } else {
+              skinPose = {
+                identity: skinPaletteIdentity(world, entity),
+                generation: (skeletonHandleRaw >>> 0 ^ skeleton.jointCount) >>> 0,
+                jointCount: skeleton.jointCount,
+                ...hasFiniteOrderedLocalAabb(skeleton.bounds) ? { bounds: new Float32Array(skeleton.bounds) } : {},
+                inverseBindMatrices: ibms,
+                jointWorlds
+              };
             }
           }
         }
-        if (skinSlice === void 0 && hasSkin) {
+        if (skinSlice === void 0 && skinPose === void 0 && hasSkin) {
           releaseSkinIdentity();
           if (materialSnap.materialShaderId === "forgeax::pbr-skin" || materialProgramSelections?.some(materialProgramSelectionRequiresSkin) === true) {
             pendingDispatch.length = 0;
@@ -3781,9 +4716,9 @@ function extractFrame(world, context) {
         let instancesSnap;
         if (hasInstances) {
           const transforms = worldInternal._getArrayView(entity, Instances, "transforms") ?? new Float32Array();
-          const invalid = validateInstanceTransforms(transforms);
-          if (invalid !== void 0) {
-            worldInternal._routeError(invalid, {
+          const invalid5 = validateInstanceTransforms(transforms);
+          if (invalid5 !== void 0) {
+            worldInternal._routeError(invalid5, {
               severity: Severity.Error,
               systemName: "RenderSystem.extract (Instances transforms)"
             });
@@ -3816,13 +4751,14 @@ function extractFrame(world, context) {
           entityKey: entity,
           ...authorVisible ? {} : { authorVisible: false },
           ...skinSlice !== void 0 ? { skin: skinSlice } : {},
+          ...skinPose === void 0 ? {} : { skinPose },
           ...skin?.joints === void 0 ? {} : { skinJointEntities: Array.from(skin.joints, (joint) => Number(joint)) },
           ...morph !== void 0 ? { morph } : {},
           ...instancesSnap !== void 0 ? { instances: instancesSnap } : {},
           ...spriteInstancesSnap !== void 0 ? { spriteInstances: spriteInstancesSnap } : {},
           ...pointsLines !== void 0 ? { pointsLines } : {}
         };
-        const gpuDrivenDraws = buildGpuDrivenDraws({
+        const gpuDrivenDraws = skinPose === void 0 ? buildGpuDrivenDraws({
           mesh: gpuDrivenMesh,
           materials: materialsArr,
           fallbackMaterial: materialSnap,
@@ -3834,7 +4770,7 @@ function extractFrame(world, context) {
               return lower?.kind === "mesh" ? lower : void 0;
             })
           }
-        });
+        }) : [];
         for (const draw of gpuDrivenDraws) {
           if (draw.preparationError === void 0) continue;
           worldInternal._routeError(draw.preparationError, {
@@ -4371,8 +5307,8 @@ function internSharedRefFromGuid(world, assetsRef, guid, brand) {
   return handle;
 }
 function resolveVideoFieldHandle(value, world, assetsRef) {
-  const texture2 = materialTextureValue(value);
-  const textureGuid = assetReferenceText(texture2?.texture ?? value);
+  const texture = materialTextureValue(value);
+  const textureGuid = assetReferenceText(texture?.texture ?? value);
   if (textureGuid === void 0) return void 0;
   const payload = assetsRef.lookup(textureGuid);
   if (payload === void 0 || payload.kind !== "video") return void 0;
@@ -4411,10 +5347,10 @@ function collectMaterialTextureCoordinates(values) {
   }
   return out;
 }
-function materialTextureSourceFields(schema) {
-  if (schema === void 0) return void 0;
+function materialTextureSourceFields(schema2) {
+  if (schema2 === void 0) return void 0;
   const fields = /* @__PURE__ */ new Set();
-  for (const entry of schema) {
+  for (const entry of schema2) {
     if (entry.type.startsWith("texture")) fields.add(entry.name);
   }
   return fields;
@@ -4607,9 +5543,15 @@ function resolveMaterialSnapshot(handleRaw, world, assetsRef, materialSnapshotCa
   if (!resolvedResult.ok) return defaultMaterialSnapshot(handleRaw);
   const resolved = resolvedResult.value;
   const allPasses = resolved.passes;
-  const materialProgramKeys = materialProgramKeysForMaterial(asset, assetsRef, materialContext);
+  const source = world.sharedRefs.resolve(tagged);
+  const programOwner = source.ok && source.value.kind === "material" ? source.value : asset;
+  const materialProgramKeys = materialProgramKeysForMaterial(
+    programOwner,
+    assetsRef,
+    materialContext
+  );
   const materialSceneIndexProgramKeys = materialSceneIndexProgramKeysForMaterial(
-    asset,
+    programOwner,
     assetsRef,
     materialContext
   );
@@ -5206,9 +6148,9 @@ function selectFogFrame(world) {
   if (state.lkg !== void 0) return state.lkg;
   throw fogSelection.error;
 }
-function textureDigest(texture2) {
+function textureDigest(texture) {
   let hash = 2166136261;
-  for (const byte of texture2.data) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+  for (const byte of texture.data) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
   return `fnv1a:${hash.toString(16).padStart(8, "0")}`;
 }
 function extractVolumeSnapshot(world, assets, worldInternal) {
@@ -5328,602 +6270,7 @@ function extractVolumeSnapshot(world, assets, worldInternal) {
     additional: validatedMembers.slice(1)
   };
 }
-var PROBE_R_MIN = R_MIN;
-var PROBE_MAX_CONTRIBUTORS = PROBE_BLEND_RECORD_CAPACITY;
-var SH_C0 = 0.28209479177387814;
-var SH_C1 = 0.4886025119029199;
-var SH_C2 = 1.0925484305920792;
-var SH_C20 = 0.31539156525252005;
-var SH_C22 = 0.5462742152960396;
-function finiteVector(values, length) {
-  if (values.length !== length) return false;
-  for (let index = 0; index < values.length; index += 1) {
-    if (!Number.isFinite(values[index])) return false;
-  }
-  return true;
-}
-function contributorIsActive(probe, radiusMinimum) {
-  return probe.admitted && Number.isFinite(probe.distance) && probe.distance >= 0 && Number.isFinite(probe.radius) && probe.radius >= radiusMinimum && probe.distance < probe.radius && finiteVector(probe.irradiance, 27);
-}
-function emptyReceipt(radiusMinimum) {
-  return {
-    activeIdentities: [],
-    admittedIdentities: [],
-    rejectedIdentities: [],
-    stableOrder: [],
-    capacity: PROBE_MAX_CONTRIBUTORS,
-    scaleRadius: radiusMinimum,
-    finite: true
-  };
-}
-function admitProbeContributors(candidates, radiusMinimum = PROBE_R_MIN) {
-  const active = candidates.filter((candidate) => contributorIsActive(candidate, radiusMinimum));
-  const overflowed = active.length > PROBE_MAX_CONTRIBUTORS;
-  const stableActive = active.slice().sort((left, right) => left.identity.localeCompare(right.identity));
-  const admitted = stableActive.slice(0, PROBE_MAX_CONTRIBUTORS);
-  const rejected = stableActive.slice(PROBE_MAX_CONTRIBUTORS);
-  const scaleRadius = active.reduce(
-    (minimum, candidate) => Math.min(minimum, candidate.radius),
-    active[0]?.radius ?? radiusMinimum
-  );
-  const receipt = {
-    activeIdentities: stableActive.map((candidate) => candidate.identity),
-    admittedIdentities: admitted.map((candidate) => candidate.identity),
-    rejectedIdentities: rejected.map((candidate) => candidate.identity),
-    stableOrder: admitted.map((candidate) => candidate.identity),
-    capacity: PROBE_MAX_CONTRIBUTORS,
-    ...overflowed ? { overflowReason: "active-count-exceeds-capacity" } : {},
-    scaleRadius,
-    finite: stableActive.every((candidate) => Number.isFinite(candidate.radius))
-  };
-  return {
-    active: stableActive,
-    admitted,
-    rejected,
-    receipt,
-    ...overflowed ? {
-      error: {
-        code: "capacity-exceeded",
-        activeCount: active.length,
-        capacity: PROBE_MAX_CONTRIBUTORS,
-        receipt
-      }
-    } : {}
-  };
-}
-function invalidInputResult(radiusMinimum, code) {
-  const receipt = emptyReceipt(radiusMinimum);
-  return {
-    terms: [],
-    rStar: radiusMinimum,
-    Q: 0,
-    C: 0,
-    S: 1,
-    SHPreblend: new Array(27).fill(0),
-    skyIrradiance: [0, 0, 0],
-    diffuse: [0, 0, 0],
-    finite: false,
-    receipt,
-    scaledQLogOffset: 0,
-    error: { code, activeCount: 0, capacity: PROBE_MAX_CONTRIBUTORS, receipt }
-  };
-}
-function neumaierSum(values) {
-  let sum = 0;
-  let correction = 0;
-  for (const value of values) {
-    const next = sum + value;
-    if (Math.abs(sum) >= Math.abs(value)) correction += sum - next + value;
-    else correction += value - next + sum;
-    sum = next;
-  }
-  return sum + correction;
-}
-function roundProbeToF32(value) {
-  return Number.isFinite(value) ? new Float32Array([value])[0] : void 0;
-}
-function scaledProbeWeight(distance, radius, radiusMinimum = PROBE_R_MIN) {
-  if (!Number.isFinite(distance) || distance < 0 || !Number.isFinite(radius) || radius < radiusMinimum || distance >= radius) {
-    return { coverage: 0, q: 0 };
-  }
-  const ratio = distance / radius;
-  const coverage = 1 - ratio * ratio;
-  return { coverage, q: coverage / (radius * radius) };
-}
-function sh9Irradiance(coefficients, normal) {
-  const x = normal[0];
-  const y = normal[1];
-  const z = normal[2];
-  const basis = [
-    SH_C0,
-    SH_C1 * y,
-    SH_C1 * z,
-    SH_C1 * x,
-    SH_C2 * x * y,
-    SH_C2 * y * z,
-    SH_C20 * (3 * z * z - 1),
-    SH_C2 * x * z,
-    SH_C22 * (x * x - y * y)
-  ];
-  const result = [0, 0, 0];
-  for (let band = 0; band < basis.length; band += 1) {
-    const factor = basis[band] ?? 0;
-    const offset = band * 3;
-    result[0] = (result[0] ?? 0) + (coefficients[offset] ?? 0) * factor;
-    result[1] = (result[1] ?? 0) + (coefficients[offset + 1] ?? 0) * factor;
-    result[2] = (result[2] ?? 0) + (coefficients[offset + 2] ?? 0) * factor;
-  }
-  return result;
-}
-function vectorNeumaierSum(values, width) {
-  return Array.from(
-    { length: width },
-    (_, channel) => neumaierSum(values.map((value) => value[channel] ?? 0))
-  );
-}
-function blendProbeCoefficients(contributors, radiusMinimum) {
-  if (contributors.length > PROBE_MAX_CONTRIBUTORS || contributors.some((contributor) => !contributorIsActive(contributor, radiusMinimum))) {
-    return void 0;
-  }
-  const rStar = contributors.reduce(
-    (minimum, contributor) => Math.min(minimum, contributor.radius),
-    contributors[0]?.radius ?? radiusMinimum
-  );
-  const rawTerms = contributors.map((contributor) => {
-    const { coverage } = scaledProbeWeight(contributor.distance, contributor.radius, radiusMinimum);
-    const scaledRatio = rStar / contributor.radius;
-    return {
-      contributor,
-      coverage,
-      // Diagnostic q is never used for Q, alpha, C, or SH accumulation.
-      q: coverage / (contributor.radius * contributor.radius),
-      scaledQ: coverage * scaledRatio * scaledRatio
-    };
-  });
-  const scaledQLogOffset = 0;
-  const finiteTerms = rawTerms;
-  if (finiteTerms.some((term) => !Number.isFinite(term.scaledQ))) return void 0;
-  const Q = neumaierSum(finiteTerms.map((term) => term.scaledQ));
-  const terms = finiteTerms.map((term) => ({
-    identity: term.contributor.identity,
-    distance: term.contributor.distance,
-    radius: term.contributor.radius,
-    coverage: term.coverage,
-    q: term.q,
-    scaledQ: term.scaledQ,
-    qHat: term.scaledQ,
-    alpha: Q > 0 ? term.scaledQ / Q : 0
-  }));
-  let product = 1;
-  for (const term of finiteTerms) product *= 1 - term.coverage;
-  const C = 1 - product;
-  const S = 1 - C;
-  const weightedSh = finiteTerms.map(
-    (term) => Array.from(term.contributor.irradiance, (value) => value * (Q > 0 ? term.scaledQ / Q : 0))
-  );
-  const SHPreblend = vectorNeumaierSum(weightedSh, 27).map((value) => value * C);
-  const finite = Number.isFinite(Q) && Number.isFinite(C) && Number.isFinite(S) && SHPreblend.every(Number.isFinite) && finiteTerms.every((term) => Number.isFinite(term.scaledQ));
-  const receipt = {
-    activeIdentities: contributors.map((contributor) => contributor.identity),
-    admittedIdentities: contributors.map((contributor) => contributor.identity),
-    rejectedIdentities: [],
-    stableOrder: contributors.map((contributor) => contributor.identity),
-    capacity: PROBE_MAX_CONTRIBUTORS,
-    scaleRadius: rStar,
-    finite
-  };
-  return {
-    terms,
-    rStar,
-    Q,
-    C,
-    S,
-    SHPreblend,
-    finite,
-    receipt,
-    scaledQLogOffset
-  };
-}
-function blendLightProbes(input) {
-  const radiusMinimum = input.radiusMinimum ?? PROBE_R_MIN;
-  const normal = input.normal;
-  const sky = input.skyIrradiance;
-  if (!finiteVector(normal, 3) || !finiteVector(sky, 3)) {
-    return invalidInputResult(radiusMinimum, "invalid-admitted-prefix");
-  }
-  const coefficients = blendProbeCoefficients(input.contributors, radiusMinimum);
-  if (coefficients === void 0)
-    return invalidInputResult(radiusMinimum, "invalid-admitted-prefix");
-  const shIrradiance = sh9Irradiance(coefficients.SHPreblend, normal);
-  const diffuse = [0, 1, 2].map(
-    (channel) => Math.max(shIrradiance[channel] ?? 0, 0) + coefficients.S * (sky[channel] ?? 0)
-  );
-  return {
-    ...coefficients,
-    skyIrradiance: [sky[0], sky[1], sky[2]],
-    diffuse,
-    finite: coefficients.finite && diffuse.every(Number.isFinite)
-  };
-}
-function vectorDistance(left, right) {
-  const dx = left[0] - right[0];
-  const dy = left[1] - right[1];
-  const dz = left[2] - right[2];
-  return Math.hypot(dx, dy, dz);
-}
-function encodeProbeRecord(objectKey, generation, localBlendFraction, shPreblend, candidate, accepted, lastKnownGood, sentinel) {
-  const values = new Float32Array(PROBE_BLEND_RECORD_BYTE_SIZE / Float32Array.BYTES_PER_ELEMENT);
-  values[0] = objectKey;
-  values[1] = generation;
-  values[2] = roundProbeToF32(localBlendFraction) ?? 0;
-  values[3] = (1 ) | (accepted ? 2 : 0) | (lastKnownGood ? 4 : 0);
-  for (let band = 0; band < 9; band += 1) {
-    const lane = 4 + band * 4;
-    values[lane] = roundProbeToF32(shPreblend[band * 3] ?? 0) ?? 0;
-    values[lane + 1] = roundProbeToF32(shPreblend[band * 3 + 1] ?? 0) ?? 0;
-    values[lane + 2] = roundProbeToF32(shPreblend[band * 3 + 2] ?? 0) ?? 0;
-    values[lane + 3] = 0;
-  }
-  const packedSh = new Array(27);
-  for (let band = 0; band < 9; band += 1) {
-    packedSh[band * 3] = values[4 + band * 4] ?? 0;
-    packedSh[band * 3 + 1] = values[5 + band * 4] ?? 0;
-    packedSh[band * 3 + 2] = values[6 + band * 4] ?? 0;
-  }
-  return {
-    objectKey,
-    generation,
-    localBlendFraction: values[2] ?? 0,
-    shPreblend: packedSh,
-    bytes: new Uint8Array(values.buffer),
-    byteLength: values.byteLength,
-    candidate,
-    accepted,
-    lastKnownGood,
-    ...sentinel === void 0 ? {} : { sentinel }
-  };
-}
-function sameList(left, right) {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-function sameVector3(left, right) {
-  return left[0] === right[0] && left[1] === right[1] && left[2] === right[2];
-}
-function sameProbeFacts(left, right) {
-  if (left.length !== right.length) return false;
-  return left.every((probe, index) => {
-    const other = right[index];
-    if (other === void 0 || probe.identity !== other.identity || probe.radius !== other.radius || probe.admitted !== other.admitted || !sameVector3(probe.position, other.position) || probe.irradiance.length !== other.irradiance.length)
-      return false;
-    for (let value = 0; value < probe.irradiance.length; value += 1) {
-      if (probe.irradiance[value] !== other.irradiance[value]) return false;
-    }
-    return true;
-  });
-}
-function sameSkyFacts(left, right) {
-  const leftSky = left.sky;
-  const rightSky = right.sky;
-  if (leftSky === void 0 !== (rightSky === void 0)) return false;
-  if (leftSky !== void 0 && rightSky !== void 0 && (leftSky.available !== rightSky.available || leftSky.identity !== rightSky.identity || leftSky.sourceKey !== rightSky.sourceKey || leftSky.fallbackReason !== rightSky.fallbackReason || !sameVector3(leftSky.irradiance, rightSky.irradiance)))
-    return false;
-  if (left.skyIrradiance === void 0 !== (right.skyIrradiance === void 0)) return false;
-  return left.skyIrradiance === void 0 || right.skyIrradiance !== void 0 && sameVector3(left.skyIrradiance, right.skyIrradiance);
-}
-var ProbeBlendSceneProjection = class {
-  previous;
-  records = /* @__PURE__ */ new Map();
-  lastError;
-  lastReceipt = emptyReceipt(PROBE_R_MIN);
-  lastActiveContributorCount = 0;
-  lastAdmittedProbeCount = 0;
-  lastCoverage = 0;
-  lastFinite = true;
-  lastSky = {
-    available: false,
-    irradiance: [0, 0, 0],
-    fallbackReason: "no-skylight"
-  };
-  lastDirtyVisitCount = 0;
-  lastDirtyReasons = [];
-  bufferProjectionSource = Object.freeze({});
-  bufferProjection = Object.freeze({
-    sourceIdentity: this.bufferProjectionSource,
-    revision: 0,
-    baseRevision: 0,
-    capacity: 1,
-    records: Object.freeze([]),
-    dirtyRecords: Object.freeze([]),
-    removedCacheKeys: Object.freeze([])
-  });
-  resultRecords = Object.freeze([]);
-  recordFacts = /* @__PURE__ */ new Map();
-  getRecord(objectKey) {
-    return this.records.get(objectKey);
-  }
-  hasRecords() {
-    return this.records.size > 0;
-  }
-  /** Stable upload projection; rebuilt only when probe/object facts change. */
-  recordBufferProjection() {
-    return this.bufferProjection;
-  }
-  inspect() {
-    return {
-      activeContributorCount: this.lastActiveContributorCount,
-      admittedProbeCount: this.lastAdmittedProbeCount,
-      coverage: this.lastCoverage,
-      skyResidualFraction: 1 - this.lastCoverage,
-      finite: this.lastFinite,
-      errorCode: this.lastError?.code,
-      records: [...this.records.values()].map((record) => {
-        const facts = this.recordFacts.get(record.objectKey);
-        return {
-          objectKey: record.objectKey,
-          generation: record.generation,
-          localBlendFraction: record.localBlendFraction,
-          shPreblend: [...record.shPreblend],
-          byteLength: record.byteLength,
-          candidate: record.candidate,
-          accepted: record.accepted,
-          lastKnownGood: record.lastKnownGood,
-          sentinel: record.sentinel,
-          probeBlendIndex: record.objectKey,
-          contributors: (facts?.contributors ?? []).map((term) => ({
-            identity: term.identity,
-            distance: term.distance,
-            radius: term.radius,
-            coverage: term.coverage,
-            q: term.q,
-            qHat: term.qHat,
-            alpha: term.alpha
-          })),
-          qHatSum: facts?.qHatSum ?? 0,
-          rStar: facts?.rStar ?? PROBE_R_MIN,
-          fallbackReason: facts?.fallbackReason
-        };
-      }),
-      sky: {
-        available: this.lastSky?.available ?? false,
-        identity: this.lastSky?.identity,
-        sourceKey: this.lastSky?.sourceKey,
-        irradiance: [...this.lastSky?.irradiance ?? [0, 0, 0]],
-        fallbackReason: this.lastSky?.fallbackReason
-      },
-      dirtyVisitCount: this.lastDirtyVisitCount,
-      dirtyReasons: [...this.lastDirtyReasons],
-      receipt: {
-        activeIdentities: [...this.lastReceipt.activeIdentities],
-        admittedIdentities: [...this.lastReceipt.admittedIdentities],
-        rejectedIdentities: [...this.lastReceipt.rejectedIdentities],
-        stableOrder: [...this.lastReceipt.stableOrder],
-        capacity: this.lastReceipt.capacity,
-        scaleRadius: this.lastReceipt.scaleRadius,
-        finite: this.lastReceipt.finite,
-        overflowReason: this.lastReceipt.overflowReason
-      }
-    };
-  }
-  apply(input) {
-    const dirtyReasons = [];
-    const affectedObjectKeys = /* @__PURE__ */ new Set();
-    const previous = this.previous;
-    if (previous !== void 0 && previous.objects === input.objects && input.worldRevision === previous.worldRevision && input.retainSkyResidualRecords === previous.retainSkyResidualRecords && sameProbeFacts(input.probes, previous.probes) && sameSkyFacts(input, previous)) {
-      return {
-        records: this.resultRecords,
-        contributors: [],
-        activeContributorCount: this.lastActiveContributorCount,
-        admittedProbeCount: this.lastAdmittedProbeCount,
-        coverage: this.lastCoverage,
-        skyResidualFraction: 1 - this.lastCoverage,
-        dirtyReasons: [],
-        affectedObjectKeys: [],
-        visits: 0,
-        allocations: 0,
-        uploads: 0,
-        receipt: this.lastReceipt,
-        ...this.lastError === void 0 ? {} : { error: this.lastError }
-      };
-    }
-    const objectKeys = input.objects.map((object) => String(object.objectKey)).sort();
-    const previousObjectKeys = previous?.objects.map((object) => String(object.objectKey)).sort() ?? [];
-    if (previous === void 0 || !sameList(objectKeys, previousObjectKeys)) {
-      dirtyReasons.push("object-boundary");
-      for (const object of input.objects) affectedObjectKeys.add(object.objectKey);
-    }
-    if (previous !== void 0 && input.worldRevision !== previous.worldRevision)
-      dirtyReasons.push("world");
-    if (previous !== void 0 && (!sameProbeFacts(input.probes, previous.probes) || input.retainSkyResidualRecords !== previous.retainSkyResidualRecords))
-      dirtyReasons.push("probe-fact");
-    if (previous !== void 0 && !sameSkyFacts(input, previous)) dirtyReasons.push("sky");
-    const previousObjects = new Map(previous?.objects.map((object) => [object.objectKey, object]));
-    for (const object of input.objects) {
-      const oldObject = previousObjects.get(object.objectKey);
-      if (oldObject === void 0) {
-        affectedObjectKeys.add(object.objectKey);
-        continue;
-      }
-      if (!sameVector3(object.position, oldObject.position)) {
-        dirtyReasons.push("object-position");
-        affectedObjectKeys.add(object.objectKey);
-      }
-      if (object.generation !== oldObject.generation) {
-        dirtyReasons.push("generation");
-        affectedObjectKeys.add(object.objectKey);
-      }
-    }
-    if (dirtyReasons.includes("world") || dirtyReasons.includes("probe-fact") || dirtyReasons.includes("sky"))
-      for (const object of input.objects) affectedObjectKeys.add(object.objectKey);
-    const uniqueDirtyReasons = [...new Set(dirtyReasons)];
-    if (previous !== void 0 && uniqueDirtyReasons.length === 0) {
-      return {
-        records: [...this.records.values()],
-        contributors: [],
-        activeContributorCount: this.lastActiveContributorCount,
-        admittedProbeCount: this.lastAdmittedProbeCount,
-        coverage: this.lastCoverage,
-        skyResidualFraction: 1 - this.lastCoverage,
-        dirtyReasons: [],
-        affectedObjectKeys: [],
-        visits: 0,
-        allocations: 0,
-        uploads: 0,
-        receipt: this.lastReceipt,
-        ...this.lastError === void 0 ? {} : { error: this.lastError }
-      };
-    }
-    const nextRecords = new Map(this.records);
-    const currentObjectKeys = new Set(input.objects.map((object) => object.objectKey));
-    for (const objectKey of nextRecords.keys()) {
-      if (!currentObjectKeys.has(objectKey)) {
-        nextRecords.delete(objectKey);
-        this.recordFacts.delete(objectKey);
-      }
-    }
-    let firstTerms = [];
-    let firstReceipt = emptyReceipt(PROBE_R_MIN);
-    let firstError;
-    let firstActiveCount = 0;
-    let firstAdmittedCount = 0;
-    let firstCoverage = 0;
-    let firstObjectSeen = false;
-    let visited = 0;
-    for (const object of input.objects) {
-      if (!affectedObjectKeys.has(object.objectKey)) continue;
-      visited += 1;
-      const candidates = input.probes.map((probe) => ({
-        identity: probe.identity,
-        admitted: probe.admitted,
-        distance: vectorDistance(object.position, probe.position),
-        radius: probe.radius,
-        irradiance: probe.irradiance
-      }));
-      const admission = admitProbeContributors(candidates);
-      if (!firstObjectSeen) {
-        firstObjectSeen = true;
-        firstActiveCount = admission.active.length;
-        firstAdmittedCount = admission.admitted.length;
-        firstReceipt = admission.receipt;
-      }
-      const previousRecord = this.records.get(object.objectKey);
-      const lastKnownGood = input.lastKnownGood ?? previousRecord?.lastKnownGood ?? false;
-      let record;
-      if (admission.error !== void 0) firstError ??= admission.error;
-      if (admission.admitted.length === 0) {
-        if (input.probes.length === 0 && input.retainSkyResidualRecords !== true) {
-          nextRecords.delete(object.objectKey);
-          this.recordFacts.delete(object.objectKey);
-          continue;
-        }
-        const sentinel = lastKnownGood ? "no-active" : "no-lkg";
-        record = encodeProbeRecord(
-          object.objectKey,
-          object.generation,
-          0,
-          new Array(27).fill(0),
-          true,
-          false,
-          lastKnownGood,
-          sentinel
-        );
-        this.recordFacts.set(object.objectKey, {
-          contributors: [],
-          qHatSum: 0,
-          rStar: PROBE_R_MIN,
-          fallbackReason: admission.error?.code ?? sentinel
-        });
-      } else {
-        const blend = blendProbeCoefficients(admission.admitted, PROBE_R_MIN);
-        if (blend === void 0) {
-          firstError ??= {
-            code: "invalid-admitted-prefix",
-            activeCount: admission.active.length,
-            capacity: PROBE_MAX_CONTRIBUTORS,
-            receipt: admission.receipt
-          };
-          firstReceipt = admission.receipt;
-          continue;
-        }
-        record = encodeProbeRecord(
-          object.objectKey,
-          object.generation,
-          blend.C,
-          blend.SHPreblend,
-          true,
-          true,
-          true,
-          void 0
-        );
-        this.recordFacts.set(object.objectKey, {
-          contributors: blend.terms,
-          qHatSum: blend.Q,
-          rStar: blend.rStar,
-          fallbackReason: admission.error === void 0 ? void 0 : "capacity-exceeded-stable-prefix"
-        });
-        if (firstTerms.length === 0) firstTerms = blend.terms;
-        firstCoverage = blend.C;
-      }
-      nextRecords.set(object.objectKey, record);
-      firstError ??= admission.error;
-    }
-    const allocations = previous === void 0 ? nextRecords.size : 0;
-    const resultRecords = Object.freeze([...nextRecords.values()]);
-    const result = {
-      records: resultRecords,
-      contributors: firstTerms,
-      activeContributorCount: firstActiveCount,
-      admittedProbeCount: firstAdmittedCount,
-      coverage: firstCoverage,
-      skyResidualFraction: 1 - firstCoverage,
-      dirtyReasons: uniqueDirtyReasons,
-      affectedObjectKeys: [...affectedObjectKeys].sort((left, right) => left - right),
-      visits: visited,
-      allocations,
-      uploads: nextRecords.size,
-      receipt: firstReceipt,
-      ...firstError === void 0 ? {} : { error: firstError }
-    };
-    const projectedRecords = Object.freeze(
-      [...nextRecords].map(([objectKey, record]) => Object.freeze({ cacheKey: objectKey, record }))
-    );
-    const dirtyRecords = Object.freeze(
-      projectedRecords.filter(({ record }) => affectedObjectKeys.has(record.objectKey))
-    );
-    const removedCacheKeys = Object.freeze(
-      [...this.records.keys()].filter((objectKey) => !nextRecords.has(objectKey))
-    );
-    const capacity = projectedRecords.reduce(
-      (value, { record }) => Math.max(value, record.objectKey + 2),
-      1
-    );
-    this.previous = input;
-    this.records = nextRecords;
-    this.resultRecords = resultRecords;
-    const baseRevision = this.bufferProjection.revision;
-    this.bufferProjection = Object.freeze({
-      sourceIdentity: this.bufferProjectionSource,
-      revision: baseRevision + 1,
-      baseRevision,
-      capacity,
-      records: projectedRecords,
-      dirtyRecords,
-      removedCacheKeys
-    });
-    this.lastError = firstError;
-    this.lastReceipt = firstReceipt;
-    this.lastActiveContributorCount = firstActiveCount;
-    this.lastAdmittedProbeCount = firstAdmittedCount;
-    this.lastCoverage = firstCoverage;
-    this.lastFinite = this.resultRecords.every(
-      (record) => record.bytes.length === PROBE_BLEND_RECORD_BYTE_SIZE
-    );
-    this.lastSky = input.sky ?? (input.skyIrradiance === void 0 ? { available: false, irradiance: [0, 0, 0], fallbackReason: "no-skylight" } : { available: true, irradiance: input.skyIrradiance });
-    this.lastDirtyVisitCount = visited;
-    this.lastDirtyReasons = uniqueDirtyReasons;
-    return result;
-  }
-};
 
-export { InstanceBoundsCache, OcclusionRenderRuntime, PROBE_MAX_CONTRIBUTORS, ProbeBlendSceneProjection, SSR_HISTORY_FORMAT, SsrHistoryOwner, admitProbeContributors, blendLightProbes, buildRectAreaWorldFrame, buildShadowFrusta, createCookieProjectionMatrixData, createExtendedLightingState, createSsrHistoryOwner, createSsrSpatialResources, emptyBloomInspection, estimateSsrSpatialMemory, extractFrames, fingerprintNumericArray, glyphTextLayoutSystem, primitiveKey, primitiveKeyId, projectBarrelDistortionInspection, projectExtendedLightingInspection, promoteExtendedLightingCandidate, recordExtendedLightingFailure, rectAreaFacesPoint, scaledProbeWeight, setOcclusionRuntimeTestHooks, viewKey, viewKeyId };
-//# sourceMappingURL=chunk-UI5SFODX.mjs.map
-//# sourceMappingURL=chunk-UI5SFODX.mjs.map
+export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, BarrelDistortion, CAMERA_BLOOM_INTENSITY_MAX, CAMERA_BLOOM_INTENSITY_MIN, CAMERA_BLOOM_SCATTER_MAX, CAMERA_BLOOM_SCATTER_MIN, CAMERA_BLOOM_SOFT_KNEE_MAX, CAMERA_BLOOM_SOFT_KNEE_MIN, CAMERA_BLOOM_THRESHOLD_MAX, CAMERA_BLOOM_THRESHOLD_MIN, CAMERA_EXPOSURE_MODE_AUTO, CAMERA_EXPOSURE_MODE_MANUAL, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CAMERA_TEMPERATURE_MAX, CAMERA_TEMPERATURE_MIN, CAMERA_TINT_MAX, CAMERA_TINT_MIN, CLOUD_EXTINCTION_COEFFICIENT, CLOUD_QUALITY_PROFILES, CUBE_CAMERA_FACE_ORDER, CUBE_CAMERA_UPDATE_CONTINUOUS, CUBE_CAMERA_UPDATE_ONCE, CUBE_CAMERA_UPDATE_ON_DEMAND, Camera, CameraError, CloudLayer, CloudLayerCacheInvalidError, CloudLayerCapabilityMissingError, CloudLayerInvalidParameterError, CloudLayerOwnerConflictError, CloudLayerResourceFailureError, CloudQualityValue, CubeCamera, DEFAULT_CLOUD_LAYER, DEFAULT_DEPTH_OF_FIELD_PARAMS, DEPTH_OF_FIELD_PARAMS_BYTE_SIZE, DepthOfField, DepthOfFieldQualityValue, DepthOfFieldSideValue, DepthOfFieldValidationError, DirectionalLight, DirectionalShadowFilterValue, DynamicResolution, Fog, Instances, Layer, LightProbe, Lines, MAX_VOLUMETRIC_FOG_OWNERS, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, PointShapeValue, Points, PostProcessParams, REFLECTION_PROBE_UPDATE_CONTINUOUS, REFLECTION_PROBE_UPDATE_ONCE, REFLECTION_PROBE_UPDATE_ON_CHANGE, RectAreaLight, ReflectionProbe, SKYBOX_MODE_CUBEMAP, SKYLIGHT_RECOVERY_FALLBACK, SceneInstance, ScreenSpaceReflection, SkyboxBackground, Skylight, SortKey, SpotLight, SunCardinalityError, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, Visibility, VisibilityStateValue, VolumetricFog, VolumetricFogSamplingValue, attachBarrelDistortionCameraFrame, buildCubeCameraFaceViews, buildRectAreaWorldFrame, buildShadowFrusta, cameraExposureFromColumns, cameraProjectionFromF32, cloudLayerFormationKey, cloudLayerSourceKey, cloudQualityFromF32, cloudShadowResolutionForQuality, cloudViewDistanceForQuality, computeInvRangeSquared, createBarrelDistortionMapping, createCookieProjectionMatrixData, cubeCameraUpdateIntentFromF32, cubeCameraUpdateIntentToF32, degToCos, depthOfFieldQualityCode, depthOfFieldQualityFromF32, depthOfFieldRequestFailure, depthOfFieldSideCode, depthOfFieldSideFromF32, depthOfFieldTapCount, directionalShadowQualityFromF32, extractCloudLayer, extractFrames, extractVolumetricFog, freezeBarrelDistortionMapping, glyphTextLayoutSystem, hasVolumetricFogCapability, internSharedRefFromGuid, mapDisplayToScene, mapDisplayUvToSceneUv, mapSceneToDisplay, mapSceneUvToDisplayUv, orthographic, packDepthOfFieldParams, perspective, pointShapeFromU32, projectMeshMaterialBindingObservation, rectAreaFacesPoint, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveDepthOfFieldFrameParams, resolveDepthOfFieldParams, resolveIntegratedVolumeConsumer, resolveMaterialSnapshot, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, selectCloudLayerFrame, signedDepthOfFieldCoC, summarizeMeshMaterialBindings, validateBarrelDistortionParameters, validateCameraBloom, validateCameraColorGrading, validateCameraExposure, validateCloudLayer, validateDepthOfFieldFrameParams, validateDepthOfFieldParams, validateDirection, validateDirectionalLightData, validateDynamicResolutionCamera, validateDynamicResolutionParameters, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 };
+//# sourceMappingURL=chunk-BZQ4CDRF.mjs.map
+//# sourceMappingURL=chunk-BZQ4CDRF.mjs.map