@forgeax/engine-render 0.1.20 → 0.1.23

package/dist/{chunk-CDTWTHZR.mjs → chunk-FF7K3FSO.mjs}

@@ -1,7 +1,8 @@
-import { PointsLinesBudgetExceededError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-TBQJOK2L.mjs';
+import { RenderIntentInvalidError, ShadowInvalidConfigError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError } from './chunk-QODA5UKU.mjs';
 import { defineComponent, Entity } from '@forgeax/engine-ecs';
 import { TONEMAP_SHADER_MODE } from '@forgeax/engine-shader';
-import { err, ok } from '@forgeax/engine-types';
+import { R_MIN, err, ok } from '@forgeax/engine-types';
+import { SpawnLightInvalidBoundsError } from '@forgeax/engine-ecs/projection';
 import { Transform, projectHierarchy } from '@forgeax/engine-scene';
 
 var Atmosphere = defineComponent("Atmosphere", {
@@ -106,6 +107,10 @@ var Camera = defineComponent("Camera", {
   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
@@ -165,6 +170,75 @@ function orthographic(opts) {
     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
@@ -188,7 +262,13 @@ var DirectionalLight = defineComponent("DirectionalLight", {
   // reach. Default 200 world units (matches UE-style "dynamic shadow
   // distance"; the old farPlane default was 50).
   shadowDistance: { type: "f32", default: 200 },
-  pcfKernelSize: { type: "f32", default: 3 }
+  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]) },
@@ -202,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",
   {
@@ -276,6 +571,46 @@ 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;
+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",
   {
@@ -320,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.
@@ -372,175 +710,142 @@ var Visibility = defineComponent(
     }
   }
 );
-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");
+
+// 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");
   }
-  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"]
+  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 oneSweep(candidateCount, effectiveQueryBudget) {
+  return Math.ceil(candidateCount / effectiveQueryBudget);
+}
+
+// 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 }) }
         })
-      );
-    }
-    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");
+      }
+    });
+  });
+  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;
     }
-    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);
+  return {
+    total: ready + pending + failed + lastKnownGood,
+    ready,
+    pending,
+    failed,
+    lastKnownGood,
+    textureCount,
+    samplerCount
+  };
 }
-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 resolveMeshMaterialBindings(mesh, rendererOverrides, deps) {
+  const bindings = [];
+  const diagnostics = [];
+  if (!Array.isArray(mesh.materialSlots)) {
+    return { ok: false, code: "mesh-material-slots-missing" };
   }
-  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"
-        })
-      );
+  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({ ...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
-  });
+  return { ok: true, bindings, diagnostics };
 }
 function hasVolumetricFogCapability(caps, shaders) {
   return caps.compute && caps.storageTexture && shaders !== void 0;
@@ -689,7 +994,7 @@ function resolveVisibility(world, hierarchy = projectHierarchy(world)) {
       return result;
     };
   };
-  return {
+  const snapshot = {
     diagnostics: hierarchy.diagnostics,
     hasAnyIntent: intentCount > 0,
     hasAnyHiddenIntent,
@@ -702,6 +1007,7 @@ function resolveVisibility(world, hierarchy = projectHierarchy(world)) {
       return resolveEntity?.(entity)?.effective ?? "visible";
     }
   };
+  return snapshot;
 }
 var VolumetricFog = defineComponent("VolumetricFog", {
   light: { type: "entity" },
@@ -747,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, Camera, DirectionalLight, Fog, Instances, Layer, Lines, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, PointShapeValue, Points, PostProcessParams, 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, antialiasFromF32, bloomEnabledFromF32, cameraProjectionFromF32, extractVolumetricFog, hasVolumetricFogCapability, inspectVolumetricFog, orthographic, perspective, pointShapeFromU32, resolveIntegratedVolumeConsumer, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, tonemapFromF32, tonemapToU32, validateVolumetricFog, visibilityStateFromU32 };
-//# sourceMappingURL=chunk-CDTWTHZR.mjs.map
-//# sourceMappingURL=chunk-CDTWTHZR.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-FF7K3FSO.mjs.map
+//# sourceMappingURL=chunk-FF7K3FSO.mjs.map