@forgeax/engine-render 0.1.33 → 0.1.35

package/dist/chunk-PLAXOOX5.mjs

@@ -1,1907 +0,0 @@
-import { RenderIntentInvalidError, DynamicResolutionRequiresTaaError, ShadowInvalidConfigError, EnvironmentSourceConflictError, FogCardinalityError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, DynamicResolutionInvalidParameterError, AtmosphereInvalidParameterError } from './chunk-NB2S7ZRX.mjs';
-import { defineComponent, Entity } from '@forgeax/engine-ecs';
-import { TONEMAP_SHADER_MODE } from '@forgeax/engine-shader';
-import { R_MIN, err, ok } from '@forgeax/engine-types';
-import { SpawnLightInvalidBoundsError } from '@forgeax/engine-ecs/projection';
-import { Transform, projectHierarchy } from '@forgeax/engine-scene';
-import { mat4 } from '@forgeax/engine-math';
-
-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 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 cameraError(code, field, actual, expected, hint) {
-  return new CameraError(code, field, actualValue(actual), expected, hint);
-}
-function finitePositive(value) {
-  return Number.isFinite(value) && value > 0;
-}
-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 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]"
-    );
-  }
-}
-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"
-  );
-}
-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"
-  );
-}
-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"
-  );
-}
-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 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 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"
-  );
-}
-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 {
-    exposureMode: CAMERA_EXPOSURE_MODE_AUTO,
-    exposure: checked.fallback,
-    compensationEv: checked.compensationEv,
-    rangeEv: new Float32Array(checked.rangeEv),
-    rates: new Float32Array(checked.rates)
-  };
-}
-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 {
-    ...cameraExposureColumns(exposure),
-    temperature,
-    tint,
-    colorLut: opts.colorLut ?? 0,
-    colorLutStrength
-  };
-}
-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 {
-    // 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 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)
-  };
-}
-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;
-  }
-}
-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 invalid(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(invalid("targetGpuMs", targetGpuMs, "finite and greater than 0"));
-  }
-  if (!Number.isFinite(minScale) || minScale < 0.5 || minScale > 1) {
-    return err(invalid("minScale", minScale, "finite and in [0.5, 1.0]"));
-  }
-  if (!Number.isFinite(maxScale) || maxScale < 0.5 || maxScale > 1) {
-    return err(invalid("maxScale", maxScale, "finite and in [0.5, 1.0]"));
-  }
-  if (minScale > maxScale) {
-    return err(invalid("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", {
-  collectionId: { type: "u32", default: 0 }
-});
-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 null;
-}
-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(
-        new ShadowInvalidConfigError("shadowAngularRadius", shadowAngularRadius, {
-          kind: "range",
-          min: PCSS_RADIUS_MIN,
-          max: PCSS_RADIUS_MAX
-        })
-      );
-    }
-    if (shadowAngularRadius < Math.fround(PCSS_RADIUS_MIN) || shadowAngularRadius > Math.fround(PCSS_RADIUS_MAX)) {
-      return err(
-        new ShadowInvalidConfigError("shadowAngularRadius", shadowAngularRadius, {
-          kind: "range",
-          min: PCSS_RADIUS_MIN,
-          max: PCSS_RADIUS_MAX
-        })
-      );
-    }
-    const maxPenumbraTexels = data.maxPenumbraTexels ?? 32;
-    if (!Number.isFinite(maxPenumbraTexels) || !Number.isInteger(maxPenumbraTexels) || maxPenumbraTexels < PCSS_PENUMBRA_MIN || maxPenumbraTexels > PCSS_PENUMBRA_MAX) {
-      return err(
-        new ShadowInvalidConfigError(
-          "maxPenumbraTexels",
-          maxPenumbraTexels,
-          { kind: "range", min: PCSS_PENUMBRA_MIN, max: PCSS_PENUMBRA_MAX },
-          void 0,
-          "a finite integer in [1, 64]"
-        )
-      );
-    }
-  }
-  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"
-      )
-    );
-  }
-  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));
-  }
-  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));
-    }
-  }
-  return ok(void 0);
-}
-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)
-      )
-    );
-  }
-  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."
-    }
-  }
-);
-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."
-    }
-  }
-);
-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
-    }
-  },
-  {
-    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."
-    }
-  }
-);
-
-// 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 environmentOnlySignature(input) {
-  return JSON.stringify({
-    environments: sorted(input.environments),
-    suns: sorted(input.suns)
-  });
-}
-function fogOnlySignature(input) {
-  return JSON.stringify({ fogs: sorted(input.fogs) });
-}
-function environmentFactSignatures(input) {
-  return {
-    environmentSignature: environmentOnlySignature(input),
-    fogSignature: fogOnlySignature(input),
-    signature: environmentSignature(input)
-  };
-}
-
-// 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]"
-    };
-  }
-  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 (!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);
-    }
-  }
-  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 selected = input.environments[0];
-  if (selected?.kind === "atmosphere") {
-    const invalid3 = validateAtmosphereParameters(selected.atmosphere);
-    if (invalid3 !== void 0) return err(invalid3);
-  }
-  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 invalid2(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(invalid2(field, raw, "a finite positive f32 value"));
-    }
-  }
-  if (!Number.isFinite(fStop) || fStop < MIN_F_STOP || fStop > MAX_F_STOP) {
-    return err(
-      invalid2("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(
-      invalid2("maxRadiusPixels", params.maxRadiusPixels, "a finite f32 value in [0, 32]", [0, 32])
-    );
-  }
-  if (!Number.isFinite(outputHeight) || outputHeight <= 0) {
-    return err(invalid2("outputHeight", input.outputHeight, "a finite positive f32 value"));
-  }
-  if (far <= near) {
-    return err(invalid2("near/far", [input.near, input.far], "finite f32 near > 0 and far > near"));
-  }
-  if (focusDistance <= focal) {
-    return err(invalid2("focusDistance", params.focusDistance, "greater than focalLength in f32"));
-  }
-  const depthRatio = quantizeF32(near / far);
-  if (!Number.isFinite(depthRatio) || depthRatio <= 0) {
-    return err(invalid2("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(invalid2("linearDepth", distance, "finite positive f32 reconstruction"));
-    }
-  }
-  const cocCoefficient = frameCocCoefficient(
-    {
-      focusDistance,
-      fStop,
-      sensorHeight,
-      focalLength: focal
-    },
-    outputHeight
-  );
-  if (!Number.isFinite(cocCoefficient) || cocCoefficient <= 0) {
-    return err(
-      invalid2("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(invalid2(`coc.${field}`, radius, "a finite value representable as f32"));
-    }
-  }
-  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 quality = depthOfFieldQualityFromF32(qualityValue);
-  const blurSide = depthOfFieldSideFromF32(blurSideValue);
-  if (!Number.isFinite(focusDistance) || focusDistance <= 0) {
-    return err(
-      invalid2("focusDistance", value.focusDistance ?? focusDistance, "a finite positive f32 value")
-    );
-  }
-  if (!Number.isFinite(fStop) || fStop < MIN_F_STOP || fStop > MAX_F_STOP) {
-    return err(
-      invalid2("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(
-      invalid2("sensorHeight", value.sensorHeight ?? sensorHeight, "a finite positive f32 value")
-    );
-  }
-  if (!Number.isFinite(maxRadiusPixels) || maxRadiusPixels < 0 || maxRadiusPixels > 32) {
-    return err(
-      invalid2(
-        "maxRadiusPixels",
-        value.maxRadiusPixels ?? maxRadiusPixels,
-        "a finite f32 value in [0, 32]",
-        [0, 32]
-      )
-    );
-  }
-  if (quality === void 0) {
-    return err(invalid2("quality", qualityValue, "DepthOfFieldQualityValue.low, medium, or high"));
-  }
-  if (blurSide === void 0) {
-    return err(invalid2("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(invalid2("fov", camera.fov, "a finite f32 value in (0, PI)"));
-    }
-    if (!Number.isFinite(near) || !Number.isFinite(far) || near <= 0 || far <= near) {
-      return err(
-        invalid2("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(invalid2("focalLength", focal, "a finite positive f32 value"));
-    }
-    if (focusDistance < near || focusDistance > far) {
-      return err(
-        invalid2("focusDistance", focusDistance, `a value in [${near}, ${far}]`, [near, far])
-      );
-    }
-    if (focusDistance <= focal) {
-      return err(
-        invalid2("focusDistance", focusDistance, `greater than focalLength in f32 (${focal})`)
-      );
-    }
-  }
-  return ok(
-    Object.freeze({
-      focusDistance,
-      fStop,
-      sensorHeight,
-      maxRadiusPixels,
-      quality,
-      blurSide,
-      focalLength: focal
-    })
-  );
-}
-function resolveDepthOfFieldParams(input, camera) {
-  if (input === void 0) return ok(void 0);
-  return validateDepthOfFieldParams(input, camera);
-}
-function depthOfFieldTapCount(quality) {
-  switch (quality) {
-    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(quality) {
-  switch (quality) {
-    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"
-    };
-  }
-  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"
-    };
-  }
-  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"
-    };
-  }
-  const hasDirectional = world.hasComponent(entity, DirectionalLight);
-  const hasSpot = world.hasComponent(entity, SpotLight);
-  if (hasDirectional && hasSpot) {
-    return {
-      status: "unresolved",
-      reason: "ambiguous",
-      entity,
-      expected,
-      actual: "DirectionalLight + SpotLight",
-      hint: "remove one mutually exclusive light component from the selected entity"
-    };
-  }
-  if (hasDirectional) return { status: "available", entity, kind: "directional" };
-  if (world.hasComponent(entity, PointLight) && world.hasComponent(entity, Transform)) {
-    return { status: "available", entity, kind: "point" };
-  }
-  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 }) }
-        })
-      }
-    });
-  });
-  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;
-      }
-      textureCount += residency.textures.length;
-      samplerCount += residency.samplers.length;
-    }
-  }
-  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
-    });
-  }
-  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 (override !== 0) {
-      diagnostics.push({
-        code: "mesh-renderer-material-override-invalid",
-        slotIndex,
-        handle: override
-      });
-    }
-    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;
-    }
-    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);
-        }
-      }
-      return;
-    }
-    for (const row of query.value) {
-      visit(row.entity, row.get(Visibility).state);
-    }
-  };
-  let intentCount = 0;
-  let hasAnyHiddenIntent = false;
-  visitVisibilityRows((_entity, rawState) => {
-    intentCount += 1;
-    if (rawState === VisibilityStateValue.hidden) {
-      hasAnyHiddenIntent = true;
-    }
-  });
-  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);
-      }
-    });
-    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;
-}
-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 }
-});
-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) {
-  const ownerCount = input.ownerCount ?? 1;
-  if (ownerCount !== 1) return err(new VolumeOwnerConflictError(ownerCount));
-  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) {
-    return err(new VolumeInvalidParametersError(input));
-  }
-  return ok({ ...input, ownerCount: 1 });
-}
-function extractVolumetricFog(inputs) {
-  if (inputs.length === 0) return ok({ status: "off" });
-  if (inputs.length !== 1) return err(new VolumeOwnerConflictError(inputs.length));
-  const validated = validateVolumetricFog(inputs[0]);
-  if (!validated.ok) return validated;
-  return ok({ status: "available", fog: validated.value });
-}
-
-export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, 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, CUBE_CAMERA_FACE_ORDER, CUBE_CAMERA_UPDATE_CONTINUOUS, CUBE_CAMERA_UPDATE_ONCE, CUBE_CAMERA_UPDATE_ON_DEMAND, Camera, CameraError, CubeCamera, DEFAULT_DEPTH_OF_FIELD_PARAMS, DEPTH_OF_FIELD_PARAMS_BYTE_SIZE, DepthOfField, DepthOfFieldQualityValue, DepthOfFieldSideValue, DepthOfFieldValidationError, DirectionalLight, DirectionalShadowFilterValue, DynamicResolution, Fog, Instances, Layer, LightProbe, Lines, 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, antialiasFromF32, buildCubeCameraFaceViews, cameraExposureFromColumns, cameraProjectionFromF32, computeInvRangeSquared, cubeCameraUpdateIntentFromF32, cubeCameraUpdateIntentToF32, degToCos, depthOfFieldQualityCode, depthOfFieldQualityFromF32, depthOfFieldRequestFailure, depthOfFieldSideCode, depthOfFieldSideFromF32, depthOfFieldTapCount, directionalShadowQualityFromF32, extractVolumetricFog, hasVolumetricFogCapability, orthographic, packDepthOfFieldParams, perspective, pointShapeFromU32, projectMeshMaterialBindingObservation, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveDepthOfFieldFrameParams, resolveDepthOfFieldParams, resolveIntegratedVolumeConsumer, resolveMeshMaterialBindings, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, selectEnvironment, signedDepthOfFieldCoC, summarizeMeshMaterialBindings, tonemapFromF32, tonemapToU32, validateCameraBloom, validateCameraColorGrading, validateCameraExposure, validateDepthOfFieldFrameParams, validateDepthOfFieldParams, validateDirection, validateDirectionalLightData, validateDynamicResolutionCamera, validateDynamicResolutionParameters, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 };
-//# sourceMappingURL=chunk-PLAXOOX5.mjs.map
-//# sourceMappingURL=chunk-PLAXOOX5.mjs.map