@forgeax/engine-render 0.1.19 → 0.1.21

package/dist/chunk-FS2KNUQH.mjs

@@ -0,0 +1,1294 @@
+import { RenderIntentInvalidError, PointsLinesBudgetExceededError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-6OPXDQ2E.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 { Transform, projectHierarchy } from '@forgeax/engine-scene';
+import { createWorldProjection } from '@forgeax/engine-ecs/projection';
+
+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 }
+});
+var CAMERA_PROJECTION_PERSPECTIVE = 0;
+var CAMERA_PROJECTION_ORTHOGRAPHIC = 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 new RangeError(`Invalid tonemap mode: ${String(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 new RangeError(
+    `Invalid antialias value: ${value}. Expected ${ANTIALIAS_NONE} (none), ${ANTIALIAS_FXAA} (fxaa), ${ANTIALIAS_MSAA} (msaa), or ${ANTIALIAS_TAA} (taa).`
+  );
+}
+var BLOOM_DISABLED = 0;
+var BLOOM_ENABLED = 1;
+function bloomEnabledFromF32(value) {
+  if (value === BLOOM_DISABLED) return "off";
+  if (value === BLOOM_ENABLED) return "on";
+  throw new RangeError(
+    `Invalid bloom value: ${value}. Expected ${BLOOM_DISABLED} (off) or ${BLOOM_ENABLED} (on).`
+  );
+}
+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 },
+  whitePoint: { type: "f32", default: 4 },
+  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 },
+  bloomBlurRadius: { type: "f32", default: 4 },
+  // 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 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 } : {}
+  };
+}
+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
+  };
+}
+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 }
+});
+
+// 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: 5e-3 },
+  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 Fog = defineComponent("Fog", {
+  color: { type: "array<f32, 3>", default: new Float32Array([0.5, 0.5, 0.5]) },
+  density: { type: "f32", default: 0.01 },
+  heightFalloff: { type: "f32", default: 0 },
+  maxOpacity: { type: "f32", default: 1 }
+});
+var Instances = defineComponent("Instances", {
+  transforms: { type: "array<f32>" }
+});
+var Layer = defineComponent("Layer", {
+  value: { type: "i32", default: 0 }
+});
+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 }
+});
+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 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 },
+  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 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 },
+  // 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."
+    }
+  }
+);
+function invalidStyle(input, component, field, value, expected) {
+  return err(new PointsLinesInvalidStyleError({ entity: input.entity, component, field, value, expected }));
+}
+function topologyMismatch(input, submesh, expected, actual) {
+  return err(new PointsLinesTopologyMismatchError({ entity: input.entity, submesh, expected, actual }));
+}
+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 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;
+  }
+  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"
+      })
+    );
+  }
+  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"
+      })
+    );
+  }
+  return ok(void 0);
+}
+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"
+        })
+      );
+    }
+  }
+  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"
+        })
+      );
+    }
+  }
+  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.");
+  }
+}
+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,
+    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 };
+}
+
+// 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;
+    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";
+    }
+  };
+  VISIBILITY_CACHE.set(world, { changes, hierarchy, snapshot });
+  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_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