@forgeax/engine-render 0.1.21 → 0.1.24

package/dist/{chunk-FS2KNUQH.mjs → chunk-Q752SHI5.mjs}

@@ -1,10 +1,9 @@
-import { RenderIntentInvalidError, PointsLinesBudgetExceededError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-6OPXDQ2E.mjs';
+import { RenderIntentInvalidError, ShadowInvalidConfigError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError } from './chunk-RR5L4SRS.mjs';
 import { defineComponent, Entity } from '@forgeax/engine-ecs';
 import { TONEMAP_SHADER_MODE } from '@forgeax/engine-shader';
-import { err, ok } from '@forgeax/engine-types';
-import { mat4 } from '@forgeax/engine-math';
+import { R_MIN, err, ok } from '@forgeax/engine-types';
+import { SpawnLightInvalidBoundsError } from '@forgeax/engine-ecs/projection';
 import { Transform, projectHierarchy } from '@forgeax/engine-scene';
-import { createWorldProjection } from '@forgeax/engine-ecs/projection';
 
 var Atmosphere = defineComponent("Atmosphere", {
   turbidity: { type: "f32", default: 2 },
@@ -283,6 +282,221 @@ var Instances = defineComponent("Instances", {
 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 < PCSS_RADIUS_MIN || shadowAngularRadius > 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",
   {
@@ -357,6 +571,13 @@ var schema = {
   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;
@@ -434,6 +655,9 @@ var SpotLight = defineComponent("SpotLight", {
   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.
@@ -486,217 +710,118 @@ var Visibility = defineComponent(
     }
   }
 );
-function invalidStyle(input, component, field, value, expected) {
-  return err(new PointsLinesInvalidStyleError({ entity: input.entity, component, field, value, expected }));
+
+// src/scene/visibility/budget.ts
+var DEFAULT_CONFIGURED_QUERY_BUDGET = 2048;
+var MAX_QUERY_BUDGET = 4096;
+var VISIBILITY_CANDIDATE_COUNT = 1e5;
+var VISIBILITY_OCCLUDED_COUNT = 9e4;
+function createVisibilityBudget(configuredQueryBudget = DEFAULT_CONFIGURED_QUERY_BUDGET) {
+  if (!Number.isSafeInteger(configuredQueryBudget) || configuredQueryBudget <= 0) {
+    throw new RangeError("configuredQueryBudget must be a positive safe integer");
+  }
+  const effectiveQueryBudget = Math.min(configuredQueryBudget, MAX_QUERY_BUDGET);
+  const oneSweepCandidates = oneSweep(VISIBILITY_CANDIDATE_COUNT, effectiveQueryBudget);
+  const oneSweepOccluded = oneSweep(VISIBILITY_OCCLUDED_COUNT, effectiveQueryBudget);
+  const retestSubmits = Math.max(6, oneSweepOccluded);
+  return Object.freeze({
+    configuredQueryBudget,
+    effectiveQueryBudget,
+    oneSweepCandidates,
+    oneSweepOccluded,
+    settleSubmits: 2 * oneSweepCandidates,
+    retestSubmits,
+    expirySubmits: Math.max(8, retestSubmits + oneSweepOccluded)
+  });
 }
-function topologyMismatch(input, submesh, expected, actual) {
-  return err(new PointsLinesTopologyMismatchError({ entity: input.entity, submesh, expected, actual }));
+function oneSweep(candidateCount, effectiveQueryBudget) {
+  return Math.ceil(candidateCount / effectiveQueryBudget);
 }
-function checkStyle(input) {
-  const hasPoints = input.points !== void 0;
-  const hasLines = input.lines !== void 0;
-  if (hasPoints && hasLines) {
-    return invalidStyle(
-      input,
-      "Points/Lines",
-      "components",
-      "Points + Lines",
-      "exactly one style component"
-    );
-  }
-  if (!hasPoints && !hasLines) {
-    return invalidStyle(input, "Points/Lines", "components", void 0, "one style component");
-  }
-  if (hasPoints) {
-    const sizePx = input.points?.sizePx ?? 4;
-    const shapeValue = input.points?.shape ?? PointShapeValue.square;
-    const shape = pointShapeFromU32(shapeValue);
-    if (!Number.isFinite(sizePx) || sizePx <= 0) {
-      return invalidStyle(input, "Points", "sizePx", sizePx, "finite sizePx > 0");
-    }
-    if (shape === void 0) {
-      return invalidStyle(input, "Points", "shape", shapeValue, "shape is 'square' or 'circle'");
-    }
-    return ok({ component: "Points", shape, sizePx });
-  }
-  const widthPx = input.lines?.widthPx ?? 1;
-  if (!Number.isFinite(widthPx) || widthPx <= 0) {
-    return invalidStyle(input, "Lines", "widthPx", widthPx, "finite widthPx > 0");
-  }
-  return ok({ component: "Lines", widthPx });
+function hasVolumetricFogCapability(caps, shaders) {
+  return caps.compute && caps.storageTexture && shaders !== void 0;
 }
-function checkTopology(input, component) {
-  const expected = component === "Points" ? "point-list" : "line-list";
-  let pointCount = 0;
-  let segmentCount = 0;
-  const acceptedSubmeshes = [];
-  let sawNonEmpty = false;
-  for (const [submeshIndex, submesh] of input.mesh.submeshes.entries()) {
-    const indexed = input.mesh.indices !== void 0 && submesh.indexCount > 0;
-    const elementCount = indexed ? submesh.indexCount : submesh.vertexCount;
-    if (elementCount === 0) continue;
-    sawNonEmpty = true;
-    if (component === "Lines" && submesh.topology === "line-strip") {
-      return err(
-        new PointsLinesStyleUnsupportedError({
-          lane: "admission",
-          field: "topology",
-          member: "line-strip",
-          supported: ["line-list"]
-        })
-      );
-    }
-    if (submesh.topology !== expected) {
-      return topologyMismatch(input, submeshIndex, expected, submesh.topology);
-    }
-    if (component === "Lines" && elementCount % 2 !== 0) {
-      return topologyMismatch(input, submeshIndex, "line-list pairs", "line-list odd tail");
-    }
-    acceptedSubmeshes.push(submeshIndex);
-    if (component === "Points") pointCount += elementCount;
-    else segmentCount += elementCount / 2;
+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 (!sawNonEmpty) return topologyMismatch(input, 0, expected, "empty-range");
-  return ok({ pointCount, segmentCount, submeshes: acceptedSubmeshes });
-}
-function checkMaterial(input) {
-  const passes = input.material.passes ?? [];
-  const unlitModules = /* @__PURE__ */ new Set(["forgeax_material::unlit", "forgeax::default-unlit"]);
-  if (passes.length !== 1 || passes[0] === void 0) {
-    const pass2 = passes.find(
-      (candidate) => candidate.name === "deferred" || candidate.name === "shadow-caster"
-    ) ?? passes[0];
-    return err(
-      new PointsLinesMaterialUnsupportedError({
-        entity: input.entity,
-        material: input.materialId ?? "<anonymous>",
-        pass: pass2?.name ?? "<empty>",
-        module: pass2?.program.module ?? "<empty>",
-        reason: "points-lines admission requires one unlit forward pass"
-      })
-    );
+  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 pass = passes[0];
-  const lightMode = pass.renderState?.tags?.LightMode;
-  if (!unlitModules.has(pass.program.module) || pass.name !== "forward" || lightMode === "ShadowCaster") {
-    return err(
-      new PointsLinesMaterialUnsupportedError({
-        entity: input.entity,
-        material: input.materialId ?? "<anonymous>",
-        pass: pass.name,
-        module: pass.program.module,
-        reason: "points-lines admission requires an engine-owned unlit forward pass"
-      })
-    );
+  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 ok(void 0);
+  return { status: "available", mode: "point-spot", point, spot };
 }
-function admitPointsLines(input) {
-  const style = checkStyle(input);
-  if (!style.ok) return style;
-  const topology = checkTopology(input, style.value.component);
-  if (!topology.ok) return topology;
-  const material = checkMaterial(input);
-  if (!material.ok) return material;
-  if (style.value.component === "Points" && input.limits?.maxPoints !== void 0) {
-    if (topology.value.pointCount > input.limits.maxPoints) {
-      return err(
-        new PointsLinesBudgetExceededError({
-          lane: "admission",
-          requested: topology.value.pointCount,
-          limit: input.limits.maxPoints,
-          unit: "points"
-        })
-      );
-    }
+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"
+    };
   }
-  if (style.value.component === "Lines" && input.limits?.maxSegments !== void 0) {
-    if (topology.value.segmentCount > input.limits.maxSegments) {
-      return err(
-        new PointsLinesBudgetExceededError({
-          lane: "admission",
-          requested: topology.value.segmentCount,
-          limit: input.limits.maxSegments,
-          unit: "segments"
-        })
-      );
-    }
+  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"
+    };
   }
-  return ok({ ...style.value, ...topology.value });
-}
-
-// src/volume/inspection.ts
-function resourceStage(input) {
-  if (!input.authored || input.recovery === void 0) return "none";
-  if (input.recovery.status === "candidate") return "candidate";
-  if (input.recovery.status === "recovering") return "recovering";
-  if (input.recovery.status === "degraded") return "lkg";
-  return "accepted";
-}
-function inspectVolumetricFog(input) {
-  const recovery = input.recovery;
-  const status = !input.authored ? "off" : input.capability === "unavailable" ? "unavailable" : input.degraded === true || recovery?.status === "degraded" ? "degraded" : "available";
-  return Object.freeze({
-    status,
-    resourceStage: resourceStage(input),
-    guid: recovery?.guid,
-    generation: recovery?.generation,
-    digest: input.acceptedDigest,
-    candidateGeneration: recovery?.candidateGeneration,
-    candidateDigest: recovery?.candidateDigest,
-    lkgGeneration: recovery?.lkgGeneration,
-    candidateFailure: recovery?.candidateFailure,
-    deviceEpoch: recovery?.deviceEpoch ?? 0,
-    format: input.format,
-    passCount: input.passCount ?? 0,
-    sampleCount: input.sampleCount ?? 0,
-    memoryBytes: input.memoryBytes ?? 0,
-    resourceFacts: input.resourceFacts,
-    selectedLight: recovery?.selectedLight,
-    candidateSelectedLight: recovery?.candidateSelectedLight
-  });
-}
-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.");
+  if (hasDirectional) return { status: "available", entity, kind: "directional" };
+  if (world.hasComponent(entity, PointLight) && world.hasComponent(entity, Transform)) {
+    return { status: "available", entity, kind: "point" };
   }
-}
-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
-    });
+  if (hasSpot && world.hasComponent(entity, Transform)) {
+    return { status: "available", entity, kind: "spot" };
   }
-  return views;
+  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 };
 }
 
 // src/mesh-material-bindings.ts
@@ -808,367 +933,7 @@ function resolveMeshMaterialBindings(mesh, rendererOverrides, deps) {
   }
   return { ok: true, bindings, diagnostics };
 }
-
-// src/point-shadow-inspection.ts
-function inspectPointShadow(snapshots, shadowAtlasCapacity) {
-  const requested = snapshots.length;
-  const admitted = snapshots.reduce(
-    (count, snapshot) => snapshot.shadowAtlasLayer >= 0 && snapshot.shadowAtlasLayer < shadowAtlasCapacity ? count + 1 : count,
-    0
-  );
-  const status = requested === 0 ? "inactive" : requested > shadowAtlasCapacity || admitted !== requested ? "over-budget" : "ready";
-  return Object.freeze({
-    status,
-    requested,
-    admitted,
-    // A point shadow only samples an atlas after it owns an atlas layer. Keep
-    // these names explicit for AI diagnostics while deriving both from the
-    // one layer projection above.
-    shadowed: admitted,
-    shadowAtlasOccupancy: admitted,
-    shadowAtlasCapacity
-  });
-}
-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 };
-}
-
-// src/reflection/filter.ts
-function createProbeFilterState(input) {
-  return {
-    probeIndex: input.probeIndex,
-    faceCount: input.faceCount ?? 6,
-    mipCount: input.mipCount,
-    cursor: 0,
-    activeGeneration: input.activeGeneration ?? 0
-  };
-}
-function advanceProbeFilter(state) {
-  const total = state.faceCount * state.mipCount;
-  if (state.cursor >= total) return void 0;
-  return {
-    probeIndex: state.probeIndex,
-    faceIndex: state.cursor % state.faceCount,
-    mipLevel: Math.floor(state.cursor / state.faceCount)
-  };
-}
-function commitProbeFilterStep(state, success) {
-  if (!success) return state;
-  const nextCursor = state.cursor + 1;
-  const complete = nextCursor >= state.faceCount * state.mipCount;
-  return {
-    ...state,
-    cursor: nextCursor,
-    activeGeneration: complete ? state.activeGeneration + 1 : state.activeGeneration
-  };
-}
-function probeFilterIsSteady(state) {
-  return state.cursor >= state.faceCount * state.mipCount;
-}
-function normalize(vector) {
-  const length = Math.hypot(vector[0], vector[1], vector[2]);
-  if (length === 0) return [0, 0, 1];
-  return [vector[0] / length, vector[1] / length, vector[2] / length];
-}
-function boxProjectReflectionDirection(direction, boxCenter, halfExtents, point) {
-  const ray = normalize(direction);
-  let distance = Number.POSITIVE_INFINITY;
-  for (let axis = 0; axis < 3; axis += 1) {
-    const component = ray[axis] ?? 0;
-    if (component === 0) continue;
-    const extent = halfExtents[axis] ?? 0;
-    const edge = component > 0 ? (boxCenter[axis] ?? 0) + extent : (boxCenter[axis] ?? 0) - extent;
-    const candidate = (edge - (point[axis] ?? 0)) / component;
-    if (candidate > 0) distance = Math.min(distance, candidate);
-  }
-  if (!Number.isFinite(distance)) return ray;
-  return normalize([
-    (point[0] ?? 0) + ray[0] * distance - (boxCenter[0] ?? 0),
-    (point[1] ?? 0) + ray[1] * distance - (boxCenter[1] ?? 0),
-    (point[2] ?? 0) + ray[2] * distance - (boxCenter[2] ?? 0)
-  ]);
-}
-
-// src/reflection/gpu-table.ts
-function buildReflectionProbeTable(rows) {
-  const ordered = rows.slice().sort((a, b) => a.index - b.index);
-  const indices = /* @__PURE__ */ new Map();
-  for (const row of ordered) {
-    if (row.primitiveKey !== void 0) indices.set(row.primitiveKey, row.index);
-  }
-  const indexFor = (primitiveKey2) => indices.get(primitiveKey2);
-  return {
-    rows: Object.freeze(ordered),
-    cpuIndexByPrimitive: indexFor,
-    gpuIndexByPrimitive: indexFor
-  };
-}
-function reflectionProbeTableBytes(table) {
-  return table.rows.length * 48;
-}
-
-// src/reflection/projection.ts
-var REFLECTION_PROBE_BYTES_PER_TEXEL = 8;
-var DEFAULT_REFLECTION_PROBE_LIMITS = Object.freeze({
-  maxProbes: 16,
-  maxResolution: 256,
-  maxBytes: 64 * 1024 * 1024
-});
-function validateReflectionProbeInput(input) {
-  for (let index = 0; index < input.halfExtents.length; index += 1) {
-    const value = input.halfExtents[index];
-    if (value === void 0 || !Number.isFinite(value) || value <= 0) {
-      return {
-        ok: false,
-        error: {
-          code: "reflection-probe-input-invalid",
-          field: `halfExtents[${index}]`,
-          value,
-          expected: "a finite number greater than zero"
-        }
-      };
-    }
-  }
-  if (!Number.isFinite(input.priority)) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-probe-input-invalid",
-        field: "priority",
-        value: input.priority,
-        expected: "a finite number"
-      }
-    };
-  }
-  if (!Number.isFinite(input.intensity) || input.intensity < 0) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-probe-input-invalid",
-        field: "intensity",
-        value: input.intensity,
-        expected: "a finite number greater than or equal to zero"
-      }
-    };
-  }
-  if (!Number.isInteger(input.resolution) || input.resolution <= 0) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-probe-input-invalid",
-        field: "resolution",
-        value: input.resolution,
-        expected: "a positive integer"
-      }
-    };
-  }
-  return { ok: true };
-}
-function estimateReflectionProbeBytes(resolution, limits = DEFAULT_REFLECTION_PROBE_LIMITS) {
-  const maxResolution = limits.maxResolution ?? DEFAULT_REFLECTION_PROBE_LIMITS.maxResolution;
-  const clamped = Math.min(resolution, maxResolution);
-  let mipTexels = 0;
-  for (let size = clamped; size >= 1; size = Math.floor(size / 2)) {
-    mipTexels += size * size;
-  }
-  return mipTexels * 6 * REFLECTION_PROBE_BYTES_PER_TEXEL;
-}
-function admitReflectionProbe(input, current, limits = DEFAULT_REFLECTION_PROBE_LIMITS) {
-  const maxProbes = limits.maxProbes ?? DEFAULT_REFLECTION_PROBE_LIMITS.maxProbes;
-  const maxBytes = limits.maxBytes ?? DEFAULT_REFLECTION_PROBE_LIMITS.maxBytes;
-  const maxResolution = limits.maxResolution ?? DEFAULT_REFLECTION_PROBE_LIMITS.maxResolution;
-  const requested = estimateReflectionProbeBytes(input.resolution, { maxResolution });
-  if (input.resolution > maxResolution || current.acceptedCount >= maxProbes || current.acceptedBytes + requested > maxBytes) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-probe-budget-exceeded",
-        requested,
-        activeCount: current.acceptedCount,
-        activeBytes: current.acceptedBytes,
-        maxProbes,
-        maxBytes
-      }
-    };
-  }
-  return { ok: true, acceptedBytes: current.acceptedBytes + requested };
-}
-function contains(fact, point) {
-  return fact.halfExtents.every((extent, axis) => {
-    const center = fact.center[axis] ?? 0;
-    const coordinate = point[axis] ?? 0;
-    return Math.abs(coordinate - center) <= extent;
-  });
-}
-function normalizedDistance(fact, point) {
-  let squared = 0;
-  for (let axis = 0; axis < 3; axis += 1) {
-    const delta = (point[axis] ?? 0) - (fact.center[axis] ?? 0);
-    const extent = fact.halfExtents[axis] ?? 1;
-    squared += (delta / extent) ** 2;
-  }
-  return squared;
-}
-function isBetter(candidate, current, facts) {
-  const candidateFact = facts.find(
-    (fact) => fact.worldId === candidate.worldId && fact.entityKey === candidate.entityKey
-  );
-  const currentFact = facts.find(
-    (fact) => fact.worldId === current.worldId && fact.entityKey === current.entityKey
-  );
-  if (candidateFact === void 0 || currentFact === void 0) return false;
-  if (candidateFact.priority !== currentFact.priority)
-    return candidateFact.priority > currentFact.priority;
-  if (candidate.normalizedDistance !== current.normalizedDistance) {
-    return candidate.normalizedDistance < current.normalizedDistance;
-  }
-  return candidate.worldId < current.worldId || candidate.worldId === current.worldId && candidate.entityKey < current.entityKey;
-}
-function selectReflectionProbe(facts, primitiveCenter) {
-  let selected;
-  for (const fact of facts) {
-    if (!contains(fact, primitiveCenter)) continue;
-    const candidate = {
-      kind: "probe",
-      worldId: fact.worldId,
-      entityKey: fact.entityKey,
-      normalizedDistance: normalizedDistance(fact, primitiveCenter)
-    };
-    if (selected === void 0 || isBetter(candidate, selected, facts)) selected = candidate;
-  }
-  return selected ?? { kind: "skylight" };
-}
-function primitiveKey(worldId, entityKey) {
-  return `${worldId}:${entityKey}`;
-}
-var ReflectionProbeProjection = class {
-  revision = 0;
-  facts = [];
-  selected = /* @__PURE__ */ new Map();
-  signature = "";
-  scannedPrimitives = 0;
-  update(facts, primitives) {
-    const nextFacts = facts.slice().sort((a, b) => a.worldId - b.worldId || a.entityKey - b.entityKey);
-    const signature = JSON.stringify({ facts: nextFacts, primitives });
-    if (signature === this.signature) return this.snapshot();
-    this.signature = signature;
-    this.facts = nextFacts;
-    this.selected = /* @__PURE__ */ new Map();
-    for (const primitive of primitives) {
-      this.selected.set(
-        primitiveKey(primitive.worldId, primitive.entityKey),
-        selectReflectionProbe(nextFacts, primitive.center)
-      );
-    }
-    this.scannedPrimitives = primitives.length;
-    this.revision += 1;
-    return this.snapshot();
-  }
-  snapshot() {
-    return {
-      revision: this.revision,
-      facts: this.facts,
-      selected: this.selected,
-      scannedPrimitives: this.scannedPrimitives
-    };
-  }
-  selection(worldId, entityKey) {
-    return this.selected.get(primitiveKey(worldId, entityKey)) ?? { kind: "skylight" };
-  }
-};
-var VISIBILITY_CACHE = /* @__PURE__ */ new WeakMap();
 function resolveVisibility(world, hierarchy = projectHierarchy(world)) {
-  const cached = VISIBILITY_CACHE.get(world);
-  const changes = cached?.changes ?? createWorldProjection(world, { components: [Visibility] });
-  if (cached !== void 0) {
-    const evidence = changes.poll();
-    if (evidence.status === "delta" && evidence.changes.length === 0 && cached.hierarchy === hierarchy) {
-      return cached.snapshot;
-    }
-  }
   const query = world.query({ read: [Visibility] });
   const visitVisibilityRows = (visit) => {
     if (!query.ok) return;
@@ -1242,7 +1007,6 @@ function resolveVisibility(world, hierarchy = projectHierarchy(world)) {
       return resolveEntity?.(entity)?.effective ?? "visible";
     }
   };
-  VISIBILITY_CACHE.set(world, { changes, hierarchy, snapshot });
   return snapshot;
 }
 var VolumetricFog = defineComponent("VolumetricFog", {
@@ -1289,6 +1053,6 @@ function extractVolumetricFog(inputs) {
   return ok({ status: "available", fog: validated.value });
 }
 
-export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CUBE_CAMERA_FACE_ORDER, CUBE_CAMERA_UPDATE_CONTINUOUS, CUBE_CAMERA_UPDATE_ONCE, CUBE_CAMERA_UPDATE_ON_DEMAND, Camera, CubeCamera, DEFAULT_REFLECTION_PROBE_LIMITS, DirectionalLight, DirectionalShadowFilterValue, Fog, Instances, Layer, Lines, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, PointShapeValue, Points, PostProcessParams, REFLECTION_PROBE_UPDATE_CONTINUOUS, REFLECTION_PROBE_UPDATE_ONCE, REFLECTION_PROBE_UPDATE_ON_CHANGE, ReflectionProbe, ReflectionProbeProjection, SKYBOX_MODE_CUBEMAP, SceneInstance, SkyboxBackground, Skylight, SortKey, SpotLight, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, Visibility, VisibilityStateValue, VolumetricFog, admitPointsLines, admitReflectionProbe, advanceProbeFilter, antialiasFromF32, bloomEnabledFromF32, boxProjectReflectionDirection, buildCubeCameraFaceViews, buildReflectionProbeTable, cameraProjectionFromF32, commitProbeFilterStep, createProbeFilterState, cubeCameraUpdateIntentFromF32, cubeCameraUpdateIntentToF32, directionalShadowQualityFromF32, estimateReflectionProbeBytes, extractVolumetricFog, hasVolumetricFogCapability, inspectPointShadow, inspectVolumetricFog, orthographic, perspective, pointShapeFromU32, probeFilterIsSteady, projectMeshMaterialBindingObservation, reflectionProbeTableBytes, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveIntegratedVolumeConsumer, resolveMeshMaterialBindings, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, selectReflectionProbe, summarizeMeshMaterialBindings, tonemapFromF32, tonemapToU32, validateReflectionProbeInput, validateVolumetricFog, visibilityStateFromU32 };
-//# sourceMappingURL=chunk-FS2KNUQH.mjs.map
-//# sourceMappingURL=chunk-FS2KNUQH.mjs.map
+export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CUBE_CAMERA_FACE_ORDER, CUBE_CAMERA_UPDATE_CONTINUOUS, CUBE_CAMERA_UPDATE_ONCE, CUBE_CAMERA_UPDATE_ON_DEMAND, Camera, CubeCamera, DirectionalLight, DirectionalShadowFilterValue, 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, SceneInstance, SkyboxBackground, Skylight, SortKey, SpotLight, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, Visibility, VisibilityStateValue, VolumetricFog, antialiasFromF32, bloomEnabledFromF32, cameraProjectionFromF32, computeInvRangeSquared, createVisibilityBudget, cubeCameraUpdateIntentFromF32, cubeCameraUpdateIntentToF32, degToCos, directionalShadowQualityFromF32, extractVolumetricFog, hasVolumetricFogCapability, orthographic, perspective, pointShapeFromU32, projectMeshMaterialBindingObservation, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveIntegratedVolumeConsumer, resolveMeshMaterialBindings, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, summarizeMeshMaterialBindings, tonemapFromF32, tonemapToU32, validateDirection, validateDirectionalLightData, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 };
+//# sourceMappingURL=chunk-Q752SHI5.mjs.map
+//# sourceMappingURL=chunk-Q752SHI5.mjs.map