@forgeax/engine-render 0.1.20 → 0.1.23

package/dist/chunk-FBC4R44J.mjs

@@ -0,0 +1,1003 @@
+import { CUBE_CAMERA_FACE_ORDER, createVisibilityBudget, PointShapeValue, pointShapeFromU32 } from './chunk-FF7K3FSO.mjs';
+import { PointsLinesBudgetExceededError, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-QODA5UKU.mjs';
+import { err, ok } from '@forgeax/engine-types';
+import { mat4 } from '@forgeax/engine-math';
+import { validateR32FloatReceipt } from '@forgeax/engine-rhi';
+
+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 });
+}
+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/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/inspection.ts
+function recoveryFor(receipt, failure2) {
+  if (failure2 !== void 0) {
+    const code = failure2.code.toLowerCase();
+    if (code.includes("device") || code.includes("format") || code.includes("capability")) {
+      return "rebuild";
+    }
+    if (failure2.stage === "prepare" || failure2.stage === "filter") return "recapture";
+    if (failure2.stage === "build" || failure2.stage === "encode") return "rebuild";
+    if (failure2.stage === "finish" || failure2.stage === "submit") return "retry";
+    if (failure2.stage === "completion") {
+      if (receipt.source === "probe" && (receipt.state === "active" || receipt.state === "lkg")) {
+        return "use-LKG";
+      }
+      if (receipt.source === "skylight" && (receipt.state === "active" || receipt.state === "lkg")) {
+        return "use-Skylight";
+      }
+      if (receipt.source === "neutral" && receipt.state === "neutral") return "use-neutral";
+      return "retry";
+    }
+  }
+  if (receipt.source === "probe" && (receipt.state === "active" || receipt.state === "lkg")) {
+    return "use-LKG";
+  }
+  if (receipt.source === "skylight" || receipt.state === "lkg") return "use-Skylight";
+  return "use-neutral";
+}
+function inspectReflectionFallback(receipt, failure2) {
+  return {
+    receipt,
+    recoveryAction: recoveryFor(receipt, failure2),
+    ...failure2 === void 0 ? {} : {
+      failureStage: failure2.stage,
+      failureCode: failure2.code,
+      expected: failure2.expected,
+      ...failure2.detail === void 0 ? {} : { detail: failure2.detail }
+    }
+  };
+}
+
+// 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 resolveReflectionFallbackSource(selection, probeReady, skylightAvailable = true) {
+  if (selection.kind === "probe" && probeReady) return "probe";
+  if (skylightAvailable) return "skylight";
+  return "neutral";
+}
+function reflectionFallbackCoverage(source, fact, selection) {
+  if (source === "neutral") return 0;
+  if (source === "skylight") return 1;
+  if (fact === void 0 || selection.kind !== "probe") return 0;
+  const normalized = Math.sqrt(Math.max(0, selection.normalizedDistance));
+  return Math.max(0, Math.min(1, 1 - normalized / Math.sqrt(3)));
+}
+function reflectionFallbackSourceKey(source, selection, skylight) {
+  if (source === "probe" && selection.kind === "probe") {
+    return `probe:${selection.worldId}:${selection.entityKey}`;
+  }
+  if (source === "skylight" && skylight !== void 0) {
+    return `skylight:${skylight.entityHandle}:${skylight.equirectHandle}`;
+  }
+  return source;
+}
+function reflectionFallbackProjectionSignature(input) {
+  return JSON.stringify({
+    renderableKey: input.renderableKey,
+    sourceKey: input.sourceKey,
+    source: input.source,
+    coverage: input.coverage,
+    extent: input.extent,
+    brdfSignature: input.brdfSignature
+  });
+}
+function deriveReflectionFallbackProjection(input) {
+  if (!Number.isFinite(input.coverage) || input.coverage < 0 || input.coverage > 1) {
+    return {
+      ok: false,
+      error: {
+        code: "reflection-fallback-input-invalid",
+        field: "coverage",
+        expected: "a finite number between zero and one"
+      }
+    };
+  }
+  if (input.extent?.some((value) => !Number.isFinite(value) || value <= 0)) {
+    return {
+      ok: false,
+      error: {
+        code: "reflection-fallback-input-invalid",
+        field: "extent",
+        expected: "three finite numbers greater than zero"
+      }
+    };
+  }
+  if (input.linearHdr.some((value) => !Number.isFinite(value))) {
+    return {
+      ok: false,
+      error: {
+        code: "reflection-fallback-input-invalid",
+        field: "linearHdr",
+        expected: "four finite linear HDR values"
+      }
+    };
+  }
+  if (input.brdfSignature.length === 0) {
+    return {
+      ok: false,
+      error: {
+        code: "reflection-fallback-input-invalid",
+        field: "brdfSignature",
+        expected: "a non-empty BRDF signature"
+      }
+    };
+  }
+  const linearHdr = input.source === "neutral" ? [0, 0, 0, 0] : [...input.linearHdr];
+  return {
+    ok: true,
+    value: Object.freeze({
+      ...input.renderableKey === void 0 ? {} : { renderableKey: input.renderableKey },
+      ...input.sourceKey === void 0 ? {} : { sourceKey: input.sourceKey },
+      source: input.source,
+      coverage: input.coverage,
+      ...input.extent === void 0 ? {} : {
+        extent: Object.freeze([...input.extent])
+      },
+      linearHdr: Object.freeze(linearHdr),
+      brdfSignature: input.brdfSignature
+    })
+  };
+}
+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(
+        primitive.renderableKey ?? 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" };
+  }
+};
+
+// 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
+  });
+}
+
+// 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
+  });
+}
+
+// src/scene/visibility/inspection.ts
+var LOD_OCCLUSION_INSPECTION_SCHEMA = "forgeax::lod-occlusion-inspection::v2";
+var LOD_OCCLUSION_INSPECTION_MAX_BYTES = 16 * 1024;
+var MAX_INSPECTION_SAMPLES = 64;
+function nonNegativeInteger(name, value) {
+  if (!Number.isInteger(value) || value < 0)
+    throw new Error(`${name} must be a non-negative integer`);
+  return value;
+}
+function copyError(error) {
+  return Object.freeze({
+    code: error.code,
+    expected: error.expected,
+    hint: error.hint,
+    ...error.detail === void 0 ? {} : { detail: Object.freeze({ ...error.detail }) }
+  });
+}
+function copyFallback(fallback) {
+  return fallback.active ? Object.freeze({ ...fallback, error: copyError(fallback.error) }) : Object.freeze({ active: false });
+}
+function copySamples(samples) {
+  return Object.freeze(
+    [...samples].sort((left, right) => left.primitiveSlot - right.primitiveSlot).slice(0, MAX_INSPECTION_SAMPLES).map(
+      (sample) => Object.freeze({
+        primitiveSlot: nonNegativeInteger("sample.primitiveSlot", sample.primitiveSlot),
+        level: nonNegativeInteger("sample.level", sample.level),
+        visible: sample.visible
+      })
+    )
+  );
+}
+function copyWorldAttribution(attribution) {
+  if (attribution === void 0) {
+    return Object.freeze({ status: "unavailable", reason: "projection-only" });
+  }
+  if (attribution.status === "same-submit") {
+    if (typeof attribution.submit.build !== "string" || attribution.submit.build.length === 0) {
+      throw new Error("world.attribution.submit.build must be a non-empty string");
+    }
+    nonNegativeInteger("world.attribution.submit.frameId", attribution.submit.frameId);
+    nonNegativeInteger(
+      "world.attribution.submit.deviceGeneration",
+      attribution.submit.deviceGeneration
+    );
+    return Object.freeze({
+      status: "same-submit",
+      submit: Object.freeze({ ...attribution.submit })
+    });
+  }
+  if (attribution.status !== "unavailable" || attribution.reason !== "projection-only") {
+    throw new Error("world.attribution must declare same-submit or projection-only");
+  }
+  return Object.freeze({ status: "unavailable", reason: "projection-only" });
+}
+function copyRow(row) {
+  for (const [name, value] of Object.entries({
+    generation: row.generation,
+    candidates: row.count.candidates,
+    visible: row.count.visible,
+    occluded: row.count.occluded,
+    median: row.queryLatencyUs.median,
+    p95: row.queryLatencyUs.p95,
+    last: row.queryLatencyUs.last,
+    pageUsed: row.pagePressure.used,
+    pageCapacity: row.pagePressure.capacity
+  }))
+    nonNegativeInteger(`inspection.${name}`, value);
+  if (row.view.cameraEntity < 0 || row.view.viewGeneration < 0 || row.slot.primitiveSlot < 0 || row.slot.slotGeneration < 0) {
+    throw new Error("inspection identity values must be non-negative");
+  }
+  if (row.pagePressure.used > row.pagePressure.capacity) {
+    throw new Error("inspection page pressure exceeds capacity");
+  }
+  return Object.freeze({
+    root: Object.freeze({ ...row.root }),
+    view: Object.freeze({ ...row.view }),
+    slot: Object.freeze({ ...row.slot }),
+    generation: row.generation,
+    count: Object.freeze({ ...row.count }),
+    lodHistogram: Object.freeze(
+      row.lodHistogram.map(
+        (histogram) => Object.freeze({
+          level: nonNegativeInteger("histogram.level", histogram.level),
+          count: nonNegativeInteger("histogram.count", histogram.count)
+        })
+      )
+    ),
+    queryLatencyUs: Object.freeze({ ...row.queryLatencyUs }),
+    pagePressure: Object.freeze({ ...row.pagePressure }),
+    fallback: copyFallback(row.fallback),
+    degradation: Object.freeze({ ...row.degradation }),
+    samples: copySamples(row.samples)
+  });
+}
+function copyWorlds(worlds, fallback) {
+  const source = worlds ?? [{ attachmentId: fallback.view.attachmentId, rows: [fallback] }];
+  return Object.freeze(
+    source.map(
+      (world) => Object.freeze({
+        attachmentId: world.attachmentId,
+        rows: Object.freeze(world.rows.map((row) => copyRow(row))),
+        attribution: copyWorldAttribution(world.attribution)
+      })
+    )
+  );
+}
+function inspectLodOcclusion(input) {
+  const row = copyRow(input);
+  const defaultBudget = createVisibilityBudget();
+  const budget = input.budget ?? {
+    configuredQueryBudget: defaultBudget.configuredQueryBudget,
+    effectiveQueryBudget: defaultBudget.effectiveQueryBudget,
+    settleSubmits: defaultBudget.settleSubmits,
+    retestSubmits: defaultBudget.retestSubmits,
+    expirySubmits: defaultBudget.expirySubmits
+  };
+  for (const [name, value] of Object.entries(budget))
+    nonNegativeInteger(`inspection.budget.${name}`, value);
+  const submit = input.submit ?? {
+    frameId: input.generation,
+    build: "unknown",
+    deviceGeneration: 0
+  };
+  nonNegativeInteger("inspection.submit.frameId", submit.frameId);
+  nonNegativeInteger("inspection.submit.deviceGeneration", submit.deviceGeneration);
+  if (typeof submit.build !== "string" || submit.build.length === 0) {
+    throw new Error("inspection.submit.build must be a non-empty string");
+  }
+  const worlds = copyWorlds(input.worlds, row);
+  for (const world of worlds) {
+    if (world.attribution.status === "same-submit" && (world.attribution.submit.frameId !== submit.frameId || world.attribution.submit.build !== submit.build || world.attribution.submit.deviceGeneration !== submit.deviceGeneration)) {
+      throw new Error("world attribution must reference the parent inspection submit");
+    }
+  }
+  const inspection = Object.freeze({
+    schema: LOD_OCCLUSION_INSPECTION_SCHEMA,
+    ...row,
+    submit: Object.freeze({ ...submit }),
+    budget: Object.freeze({ ...budget }),
+    worlds
+  });
+  if (JSON.stringify(inspection).length > LOD_OCCLUSION_INSPECTION_MAX_BYTES) {
+    throw new Error(`LOD occlusion inspection exceeds ${LOD_OCCLUSION_INSPECTION_MAX_BYTES} bytes`);
+  }
+  return inspection;
+}
+function serializeLodOcclusionInspection(inspection) {
+  const serialized = JSON.stringify(inspection);
+  if (serialized.length > LOD_OCCLUSION_INSPECTION_MAX_BYTES) {
+    throw new Error(`LOD occlusion inspection exceeds ${LOD_OCCLUSION_INSPECTION_MAX_BYTES} bytes`);
+  }
+  return serialized;
+}
+function consumeLodOcclusionInspection(inspection) {
+  if (!inspection.fallback.active) return { action: "none" };
+  const { reason, error } = inspection.fallback;
+  const action = error.code.startsWith("asset-") || reason === "producer-failed" ? "rebuild" : reason === "query-failed" || reason === "page-exhausted" || reason === "device-loss" ? "retry" : "cold-cook";
+  return { action, sourceKey: inspection.root.sourceKey, reason };
+}
+var SSR_FORMAT_PROFILE = "r32float-mip-sampled-storage";
+var SSR_FORMAT_STAGES = Object.freeze([
+  "texture-create",
+  "mip-view",
+  "sampled-storage-bind-group",
+  "pipeline-bind",
+  "finish",
+  "submit",
+  "completion",
+  "readback"
+]);
+var ZERO_WORK = Object.freeze({
+  attachmentCount: 0,
+  passCount: 0,
+  bindingCount: 0,
+  resourceCount: 0,
+  historyCount: 0,
+  temporalDemand: 0
+});
+var ADMITTED_WORK = Object.freeze({
+  attachmentCount: 1,
+  passCount: 1,
+  bindingCount: 1,
+  resourceCount: 1,
+  historyCount: 0,
+  temporalDemand: 0
+});
+var ZERO_BUDGET = Object.freeze({
+  probeExecutions: 0,
+  resetCount: 0,
+  rebuildCount: 0
+});
+var ADMITTED_BUDGET = Object.freeze({
+  probeExecutions: 1,
+  resetCount: 0,
+  rebuildCount: 0
+});
+function identityFieldMismatch(expected, actual) {
+  for (const field of ["sourceHead", "sourceTree", "lockSha256", "buildSha256"]) {
+    if (expected[field] !== actual[field]) return field;
+  }
+  return void 0;
+}
+function blocked(identity, failure2, generation = 0) {
+  return Object.freeze({
+    status: "fallback-only",
+    identity,
+    generation,
+    work: ZERO_WORK,
+    budget: ZERO_BUDGET,
+    failure: failure2
+  });
+}
+function failure(code, owner, hint, detail = {}) {
+  const action = recoveryActionFor(code);
+  return Object.freeze({
+    code,
+    expected: "all producer, format, and temporal receipts share one admitted identity",
+    hint,
+    detail: Object.freeze({ owner, action, ...detail })
+  });
+}
+function recoveryActionFor(code) {
+  switch (code) {
+    case "ssr-reflection-fallback-unavailable":
+    case "ssr-receipt-identity-mismatch":
+      return "rebuild";
+    case "ssr-not-requested":
+    case "ssr-format-unavailable":
+    case "ssr-temporal-unavailable":
+    case "ssr-receipt-stale":
+      return "retry";
+  }
+}
+function receiptFailure(input, receipt, owner) {
+  const field = identityFieldMismatch(input.identity, receipt.identity);
+  if (field === void 0) return void 0;
+  return blocked(
+    input.identity,
+    failure("ssr-receipt-identity-mismatch", owner, "rebuild the owner receipt for this identity", {
+      identityField: field
+    })
+  );
+}
+function validFallback(receipt) {
+  return receipt !== void 0 && receipt.candidateVisible === false && Number.isFinite(receipt.coverage) && receipt.coverage >= 0 && receipt.coverage <= 1 && (receipt.sourceKey === void 0 || receipt.sourceKey.length > 0) && (receipt.extent === void 0 || receipt.extent.length === 3 && receipt.extent.every((value) => Number.isFinite(value) && value > 0)) && Number.isInteger(receipt.sourceGeneration) && receipt.sourceGeneration >= 0 && Number.isInteger(receipt.projectionGeneration) && receipt.projectionGeneration >= 0 && Number.isInteger(receipt.deviceGeneration) && receipt.deviceGeneration >= 0 && receipt.brdfSignature === "standard-pbr-ibl-v1" && (receipt.source === "probe" && (receipt.state === "active" || receipt.state === "lkg") || receipt.source === "skylight" && (receipt.state === "active" || receipt.state === "lkg") || receipt.source === "neutral" && receipt.state === "neutral");
+}
+function validFormat(receipt) {
+  if (receipt?.profile !== SSR_FORMAT_PROFILE || receipt.verdict !== "admitted" || receipt.evidence !== "real" || !Number.isInteger(receipt.deviceGeneration) || receipt.deviceGeneration < 0) {
+    return false;
+  }
+  if (!SSR_FORMAT_STAGES.every(
+    (stage) => receipt.stages.some((entry) => entry.stage === stage && entry.verdict === "admitted")
+  )) {
+    return false;
+  }
+  return validateR32FloatReceipt(receipt).ok;
+}
+function validTemporal(receipt) {
+  return receipt?.successfulSubmit === true && Number.isInteger(receipt.generation) && receipt.generation >= 0;
+}
+function admitSsrM0(input) {
+  if (!input.requested) {
+    return blocked(
+      input.identity,
+      failure("ssr-not-requested", "consumer", "request SSR before evaluating M0 admission")
+    );
+  }
+  if (input.reflectionFallback === void 0) {
+    return blocked(
+      input.identity,
+      failure("ssr-reflection-fallback-unavailable", "producer", "use LKG, Skylight, or neutral")
+    );
+  }
+  const fallbackIdentityFailure = receiptFailure(input, input.reflectionFallback, "producer");
+  if (fallbackIdentityFailure !== void 0) return fallbackIdentityFailure;
+  if (!validFallback(input.reflectionFallback)) {
+    return blocked(
+      input.identity,
+      failure(
+        "ssr-reflection-fallback-unavailable",
+        "producer",
+        "inspect and rebuild the producer receipt"
+      ),
+      input.reflectionFallback.projectionGeneration
+    );
+  }
+  if (input.format === void 0) {
+    return blocked(
+      input.identity,
+      failure("ssr-format-unavailable", "format", "probe the exact format profile for this device"),
+      input.reflectionFallback.projectionGeneration
+    );
+  }
+  const formatIdentityFailure = receiptFailure(input, input.format, "format");
+  if (formatIdentityFailure !== void 0) return formatIdentityFailure;
+  if (!validFormat(input.format)) {
+    return blocked(
+      input.identity,
+      failure("ssr-format-unavailable", "format", "complete the full r32float profile probe"),
+      input.reflectionFallback.projectionGeneration
+    );
+  }
+  if (input.temporal === void 0) {
+    return blocked(
+      input.identity,
+      failure(
+        "ssr-temporal-unavailable",
+        "temporal",
+        "submit the matching temporal producer receipt"
+      ),
+      input.reflectionFallback.projectionGeneration
+    );
+  }
+  const temporalIdentityFailure = receiptFailure(input, input.temporal, "temporal");
+  if (temporalIdentityFailure !== void 0) return temporalIdentityFailure;
+  if (!validTemporal(input.temporal)) {
+    return blocked(
+      input.identity,
+      failure("ssr-temporal-unavailable", "temporal", "inspect and rebuild the temporal receipt"),
+      input.reflectionFallback.projectionGeneration
+    );
+  }
+  if (input.previousGeneration !== void 0 && input.previousGeneration !== input.reflectionFallback.projectionGeneration) {
+    return blocked(
+      input.identity,
+      failure(
+        "ssr-receipt-stale",
+        "consumer",
+        "discard stale completion and reinspect the owners",
+        {
+          generation: input.reflectionFallback.projectionGeneration
+        }
+      ),
+      input.reflectionFallback.projectionGeneration
+    );
+  }
+  return Object.freeze({
+    status: "admitted",
+    identity: input.identity,
+    generation: input.reflectionFallback.projectionGeneration,
+    work: ADMITTED_WORK,
+    budget: ADMITTED_BUDGET
+  });
+}
+function projectSsrDependencies(input) {
+  const identity = input.identity;
+  const reflectionFallback = identity === void 0 || input.reflectionFallback?.identity === void 0 ? void 0 : input.reflectionFallback;
+  const format = identity === void 0 || input.format === void 0 ? void 0 : { ...input.format, identity };
+  const temporal = identity === void 0 || input.temporal === void 0 ? void 0 : { identity, ...input.temporal };
+  const admission = identity === void 0 ? blocked(
+    void 0,
+    failure(
+      input.requested ? "ssr-receipt-identity-mismatch" : "ssr-not-requested",
+      "consumer",
+      input.requested ? "bind the exact source, tree, lock, and build identity before admission" : "request SSR before evaluating M0 admission",
+      input.requested ? { identityField: "sourceHead" } : {}
+    )
+  ) : admitSsrM0({
+    requested: input.requested,
+    identity,
+    ...reflectionFallback === void 0 ? {} : { reflectionFallback },
+    ...format === void 0 ? {} : { format },
+    ...temporal === void 0 ? {} : { temporal },
+    ...input.previousGeneration === void 0 ? {} : { previousGeneration: input.previousGeneration }
+  });
+  return Object.freeze({
+    status: admission.status,
+    identity,
+    requested: input.requested,
+    reflectionFallback: input.reflectionFallback,
+    format,
+    temporal,
+    admission,
+    work: admission.work,
+    budget: admission.budget,
+    failure: admission.failure
+  });
+}
+function zeroSsrAdmissionWork() {
+  return ZERO_WORK;
+}
+function resolveSsrAdmissionGeneration(previousGeneration, nextGeneration) {
+  return {
+    changed: previousGeneration !== void 0 && nextGeneration !== void 0 && previousGeneration !== nextGeneration,
+    generation: nextGeneration
+  };
+}
+
+export { DEFAULT_REFLECTION_PROBE_LIMITS, LOD_OCCLUSION_INSPECTION_MAX_BYTES, LOD_OCCLUSION_INSPECTION_SCHEMA, ReflectionProbeProjection, SSR_FORMAT_PROFILE, SSR_FORMAT_STAGES, admitPointsLines, admitReflectionProbe, admitSsrM0, advanceProbeFilter, boxProjectReflectionDirection, buildCubeCameraFaceViews, buildReflectionProbeTable, commitProbeFilterStep, consumeLodOcclusionInspection, createProbeFilterState, deriveReflectionFallbackProjection, estimateReflectionProbeBytes, inspectLodOcclusion, inspectPointShadow, inspectReflectionFallback, inspectVolumetricFog, probeFilterIsSteady, projectSsrDependencies, reflectionFallbackCoverage, reflectionFallbackProjectionSignature, reflectionFallbackSourceKey, reflectionProbeTableBytes, resolveReflectionFallbackSource, resolveSsrAdmissionGeneration, selectReflectionProbe, serializeLodOcclusionInspection, validateReflectionProbeInput, zeroSsrAdmissionWork };
+//# sourceMappingURL=chunk-FBC4R44J.mjs.map
+//# sourceMappingURL=chunk-FBC4R44J.mjs.map