@forgeax/engine-render 0.1.28 → 0.1.30

package/dist/{chunk-J52NMQKR.mjs → chunk-7MQ3XBSP.mjs}

@@ -1,622 +1,617 @@
-import { CUBE_CAMERA_FACE_ORDER, createVisibilityBudget, PointShapeValue, pointShapeFromU32 } from './chunk-JAASCMXA.mjs';
-import { PointsLinesBudgetExceededError, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-J6KACNOH.mjs';
-import { ok, err } from '@forgeax/engine-types';
-import { mat4 } from '@forgeax/engine-math';
+import { PointShapeValue, pointShapeFromU32 } from './chunk-S5UE2T5P.mjs';
+import { PointsLinesBudgetExceededError, createVisibilityBudget, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-JRBDO2KB.mjs';
+import { err, ok } from '@forgeax/engine-types';
 import { validateR32FloatReceipt } from '@forgeax/engine-rhi';
 
-var DynamicGeometryError = class extends Error {
-  code;
-  expected;
-  hint;
-  detail;
-  constructor(code, expected, hint, detail = {}) {
-    super(`${code}: ${expected}`);
-    this.name = "DynamicGeometryError";
-    this.code = code;
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = Object.freeze({ code, ...detail });
+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"
+    );
   }
-};
-function sameCandidateCredential(candidate, committed) {
-  return candidate.candidateId === committed.candidateId && candidate.owner === committed.owner && candidate.world === committed.world && candidate.generation === committed.generation && candidate.entity === committed.entity && candidate.physicsEntity === committed.physicsEntity && candidate.gpuReady === committed.gpuReady && candidate.meshBytes === committed.meshBytes && candidate.revision === committed.revision && candidate.topologyRevision === committed.topologyRevision && candidate.materialIdentity === committed.materialIdentity && candidate.meshHandle === committed.meshHandle && candidate.fixedStep === committed.fixedStep;
+  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 cloneTypedArray(value) {
-  return new value.constructor(value);
+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 cloneMesh(mesh) {
-  const attributes = Object.fromEntries(
-    Object.entries(mesh.attributes).map(([key, value]) => [
-      key,
-      value instanceof ArrayBuffer ? value.slice(0) : value === void 0 ? void 0 : cloneTypedArray(value)
-    ])
+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/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({
-    ...mesh,
-    vertices: new Float32Array(mesh.vertices),
-    ...mesh.indices === void 0 ? {} : { indices: cloneTypedArray(mesh.indices) },
-    attributes,
-    ...mesh.aabb === void 0 ? {} : { aabb: new Float32Array(mesh.aabb) },
-    submeshes: Object.freeze(mesh.submeshes.map((submesh) => Object.freeze({ ...submesh }))),
-    materialSlots: Object.freeze(mesh.materialSlots.map((slot) => Object.freeze({ ...slot })))
+    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 cloneCandidate(candidate) {
-  return Object.freeze({ ...candidate, mesh: cloneMesh(candidate.mesh) });
-}
-function validateMesh(mesh) {
-  if (mesh.kind !== "mesh") return "MeshAsset.kind must be mesh";
-  if (!(mesh.vertices instanceof Float32Array) || mesh.vertices.length === 0 || mesh.vertices.length % 3 !== 0) {
-    return "MeshAsset.vertices must be a non-empty Float32Array with xyz triples";
-  }
-  if (mesh.indices !== void 0 && !(mesh.indices instanceof Uint16Array || mesh.indices instanceof Uint32Array)) {
-    return "MeshAsset.indices must be Uint16Array or Uint32Array";
-  }
-  if (mesh.submeshes.length === 0)
-    return "MeshAsset.submeshes must contain at least one topology range";
-  if (mesh.materialSlots.length < mesh.submeshes.length) {
-    return "MeshAsset.materialSlots must cover every submesh";
+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;
   }
-  if (mesh.vertices.some((value) => !Number.isFinite(value)))
-    return "MeshAsset.vertices must be finite";
   return void 0;
 }
-function meshByteSize(mesh) {
-  let bytes = mesh.vertices.byteLength + (mesh.indices?.byteLength ?? 0);
-  for (const value of Object.values(mesh.attributes)) {
-    if (value instanceof ArrayBuffer) bytes += value.byteLength;
-    else if (value !== void 0 && ArrayBuffer.isView(value)) bytes += value.byteLength;
-  }
-  if (mesh.aabb !== void 0) bytes += mesh.aabb.byteLength;
-  return bytes;
+function blocked(identity, failure2, generation = 0) {
+  return Object.freeze({
+    status: "fallback-only",
+    identity,
+    generation,
+    work: ZERO_WORK,
+    budget: ZERO_BUDGET,
+    failure: failure2
+  });
 }
-function createDynamicGeometryLifecycle(maxCandidates = 32, maxMeshBytes = 64 * 1024 * 1024) {
-  const records = /* @__PURE__ */ new Map();
-  const owner = {};
-  let sequence = 0;
-  let currentGeneration = 0;
-  let disposed = false;
-  let historyInvalidations = 0;
-  let latestRevision;
-  let latestFrameId;
-  let retired = 0;
-  let invalidated = 0;
-  let meshBytes = 0;
-  const latestRevisionByWorld = /* @__PURE__ */ new WeakMap();
-  const latestTopologyRevisionByWorld = /* @__PURE__ */ new WeakMap();
-  const publishedReceipts = /* @__PURE__ */ new Map();
-  const failure2 = (code, expected, hint, detail = {}) => err(new DynamicGeometryError(code, expected, hint, detail));
-  const current = (candidate) => {
-    const record = records.get(candidate.candidateId);
-    if (record === void 0 || candidate.owner !== owner || record.candidate.owner !== candidate.owner || record.candidate.world !== candidate.world || record.candidate.generation !== candidate.generation)
-      return void 0;
-    return record;
-  };
-  return {
-    prepare(input, generation) {
-      if (disposed)
-        return failure2("dynamic-geometry-disposed", "renderer is alive", "rebuild the Renderer");
-      if (input.world === null || typeof input.world !== "object") {
-        return failure2(
-          "dynamic-geometry-world-not-attached",
-          "candidate belongs to an attached World",
-          "attach the World before preparing geometry"
-        );
-      }
-      if (!Number.isInteger(input.revision) || input.revision < 0) {
-        return failure2(
-          "dynamic-geometry-invalid",
-          "geometry revision is a non-negative integer",
-          "advance the consumer revision monotonically",
-          { revision: input.revision }
-        );
-      }
-      if (generation !== currentGeneration && currentGeneration !== 0) {
-        return failure2(
-          "dynamic-geometry-generation-mismatch",
-          "candidate uses the active renderer generation",
-          "discard stale generation work and prepare again",
-          { generation, actual: currentGeneration }
-        );
-      }
-      if (records.size >= maxCandidates) {
-        return failure2(
-          "dynamic-geometry-budget-exceeded",
-          "candidate count remains within the bounded renderer budget",
-          "cancel or retire an earlier candidate before retrying",
-          { actual: records.size }
-        );
-      }
-      const invalid = validateMesh(input.mesh);
-      if (invalid !== void 0)
-        return failure2(
-          "dynamic-geometry-invalid",
-          "MeshAsset satisfies the standard geometry contract",
-          invalid
-        );
-      const candidateBytes = meshByteSize(input.mesh);
-      if (!Number.isSafeInteger(candidateBytes) || candidateBytes < 0 || meshBytes > maxMeshBytes - candidateBytes) {
-        return failure2(
-          "dynamic-geometry-budget-exceeded",
-          "candidate mesh bytes remain within the bounded renderer resource budget",
-          "cancel or retire an earlier candidate before retrying",
-          { actual: { meshBytes, candidateBytes, maxMeshBytes } }
-        );
-      }
-      const candidateId = `mesh:${generation}:${++sequence}:${input.revision}`;
-      const candidate = Object.freeze({
-        candidateId,
-        generation,
-        owner,
-        world: input.world,
-        ...input.entity === void 0 ? {} : { entity: input.entity },
-        ...input.physicsEntity === void 0 ? {} : { physicsEntity: input.physicsEntity },
-        gpuReady: input.meshHandle !== void 0,
-        meshBytes: candidateBytes,
-        revision: input.revision,
-        topologyRevision: input.topologyRevision ?? input.revision,
-        ...input.materialIdentity === void 0 ? {} : { materialIdentity: input.materialIdentity },
-        ...input.meshHandle === void 0 ? {} : { meshHandle: input.meshHandle },
-        ...input.fixedStep === void 0 ? {} : { fixedStep: input.fixedStep },
-        mesh: cloneMesh(input.mesh),
-        state: "prepared"
-      });
-      records.set(candidateId, {
-        world: input.world,
-        candidate,
-        historyInvalidated: false
-      });
-      meshBytes += candidateBytes;
-      currentGeneration = generation;
-      return ok(cloneCandidate(candidate));
-    },
-    accept(candidate, ordering) {
-      if (disposed)
-        return failure2("dynamic-geometry-disposed", "renderer is alive", "rebuild the Renderer");
-      const record = current(candidate);
-      if (record === void 0)
-        return failure2(
-          "dynamic-geometry-candidate-not-found",
-          "candidate is owned by this renderer",
-          "discard the stale credential"
-        );
-      if (candidate.generation !== currentGeneration) {
-        return failure2(
-          "dynamic-geometry-generation-mismatch",
-          "candidate generation matches the active renderer generation",
-          "prepare against the current renderer generation",
-          { candidateId: candidate.candidateId }
-        );
-      }
-      if (record.candidate.state !== "prepared") {
-        return failure2(
-          "dynamic-geometry-candidate-state",
-          "candidate is prepared exactly once before acceptance",
-          "retain the accepted or published receipt",
-          { candidateId: candidate.candidateId }
-        );
-      }
-      if (!sameCandidateCredential(candidate, record.candidate)) {
-        return failure2(
-          "dynamic-geometry-receipt-mismatch",
-          "acceptance uses the exact prepared candidate credential",
-          "discard the altered credential and use the value returned by prepare",
-          { candidateId: candidate.candidateId }
-        );
-      }
-      if (ordering !== void 0) {
-        if (ordering.world !== record.world || !Number.isInteger(ordering.fixedStep) || ordering.fixedStep < 0) {
-          return failure2(
-            "dynamic-geometry-ordering-required",
-            "acceptance ordering names the candidate World and a non-negative fixed step",
-            "submit the PhysicsWorld publication ordering for the same attached World",
-            { candidateId: candidate.candidateId, actual: ordering }
-          );
-        }
-      }
-      const newest = [...records.values()].filter(
-        (entry) => entry.candidate.candidateId !== candidate.candidateId && entry.world === record.world && entry.candidate.entity === record.candidate.entity && (entry.candidate.state === "prepared" || entry.candidate.state === "accepted")
-      ).map((entry) => entry.candidate.revision).concat(latestRevisionByWorld.get(record.world)?.get(record.candidate.entity) ?? -1).sort((a, b) => b - a)[0];
-      if (newest !== void 0 && record.candidate.revision <= newest) {
-        return failure2(
-          "dynamic-geometry-stale",
-          "accepted geometry revision is newer than the active candidate",
-          "advance topology revision before accepting",
-          { candidateId: candidate.candidateId }
-        );
-      }
-      const accepted = Object.freeze({
-        ...record.candidate,
-        ...ordering === void 0 ? {} : { fixedStep: ordering.fixedStep },
-        state: "accepted"
-      });
-      const previousTopologies = [...records.values()].filter(
-        (entry) => entry.candidate.candidateId !== candidate.candidateId && entry.world === record.world && entry.candidate.entity === record.candidate.entity
-      ).map((entry) => entry.candidate.topologyRevision);
-      const previousLatestTopology = latestTopologyRevisionByWorld.get(record.world)?.get(record.candidate.entity);
-      const newestTopology = previousTopologies.concat(previousLatestTopology === void 0 ? [] : [previousLatestTopology]).sort((a, b) => b - a)[0];
-      if (newestTopology !== void 0 && accepted.topologyRevision < newestTopology) {
-        return failure2(
-          "dynamic-geometry-stale",
-          "accepted topology revision is not older than the active geometry history",
-          "advance topology revision before accepting a replacement candidate",
-          { candidateId: candidate.candidateId }
-        );
-      }
-      if (newestTopology !== void 0 && accepted.topologyRevision > newestTopology) {
-        historyInvalidations += 1;
-        for (const previous of records.values()) {
-          if (previous.world !== record.world || previous.candidate.entity !== record.candidate.entity || previous.candidate.candidateId === candidate.candidateId || previous.candidate.topologyRevision >= accepted.topologyRevision)
-            continue;
-          if (!previous.historyInvalidated) {
-            previous.historyInvalidated = true;
-            invalidated += 1;
-          }
-        }
-      }
-      record.candidate = accepted;
-      return ok(cloneCandidate(accepted));
-    },
-    cancel(candidate, completion) {
-      const record = current(candidate);
-      if (record === void 0)
-        return failure2(
-          "dynamic-geometry-candidate-not-found",
-          "candidate is owned by this renderer",
-          "discard the stale credential"
-        );
-      if (!sameCandidateCredential(candidate, record.candidate))
-        return failure2(
-          "dynamic-geometry-receipt-mismatch",
-          "cancellation uses the exact prepared candidate credential",
-          "discard the altered credential and use the value returned by prepare",
-          { candidateId: candidate.candidateId }
-        );
-      if (record.candidate.state !== "prepared" && record.candidate.state !== "accepted") {
-        return failure2(
-          "dynamic-geometry-candidate-state",
-          "only prepared or accepted geometry can be cancelled once",
-          "retire published geometry or await the existing terminal cleanup"
-        );
-      }
-      record.candidate = Object.freeze({ ...record.candidate, state: "cancelled" });
-      const release = () => {
-        if (records.get(candidate.candidateId) !== record) return;
-        records.delete(candidate.candidateId);
-        meshBytes = Math.max(0, meshBytes - record.candidate.meshBytes);
-      };
-      if (completion === void 0) release();
-      else void completion.then(release, release);
-      return ok(void 0);
-    },
-    retire(candidate) {
-      const record = current(candidate);
-      if (record === void 0)
-        return failure2(
-          "dynamic-geometry-candidate-not-found",
-          "retirement uses a published candidate owned by this renderer",
-          "discard the stale credential and do not evict any unrelated mesh",
-          { candidateId: candidate.candidateId }
-        );
-      if (!sameCandidateCredential(candidate, record.candidate))
-        return failure2(
-          "dynamic-geometry-receipt-mismatch",
-          "retirement uses the exact published candidate credential",
-          "discard the altered credential and use the value returned by publish",
-          { candidateId: candidate.candidateId }
-        );
-      if (record.candidate.state !== "published") {
-        return failure2(
-          "dynamic-geometry-candidate-state",
-          "only published geometry can enter receipt-bound retirement",
-          "publish the candidate from a submitted frame first"
-        );
-      }
-      record.candidate = Object.freeze({ ...record.candidate, state: "retired" });
-      publishedReceipts.delete(candidate.candidateId);
-      retired += 1;
-      return ok(void 0);
-    },
-    finalizeRetirement(candidate) {
-      const record = current(candidate);
-      if (record === void 0)
-        return failure2(
-          "dynamic-geometry-candidate-not-found",
-          "retirement finalization uses a candidate retained by this lifecycle",
-          "discard the stale credential or finish the current receipt-bound retirement"
-        );
-      if (!sameCandidateCredential(candidate, record.candidate))
-        return failure2(
-          "dynamic-geometry-receipt-mismatch",
-          "retirement finalization uses the exact published candidate credential",
-          "discard the altered credential and use the value returned by publication",
-          { candidateId: candidate.candidateId }
-        );
-      if (record.candidate.state !== "retired")
-        return failure2(
-          "dynamic-geometry-candidate-state",
-          "only a retired candidate can release its deferred budget",
-          "retire the published candidate before finalizing its receipt-bound cleanup",
-          { candidateId: candidate.candidateId }
-        );
-      records.delete(candidate.candidateId);
-      meshBytes = Math.max(0, meshBytes - record.candidate.meshBytes);
-      return ok(void 0);
-    },
-    publishFrame(frame, worlds, fixedStep, canPublish) {
-      if (disposed || frame.deviceGeneration !== currentGeneration) return [];
-      const receipts = [];
-      for (const record of records.values()) {
-        const canRepeatPublished = record.candidate.state === "published" && // Attached Renderer publication revalidates the entity binding in
-        // `canPublish`, so a history-invalidated candidate can still record
-        // a real draw for its live entity. Detached lifecycle publication
-        // remains one-shot once that history is invalidated.
-        (canPublish !== void 0 || !record.historyInvalidated);
-        if (record.candidate.state !== "accepted" && !canRepeatPublished) continue;
-        if (worlds !== void 0 && !worlds.includes(record.world)) continue;
-        if (record.candidate.fixedStep !== void 0 && (fixedStep === void 0 || record.candidate.fixedStep > fixedStep)) {
-          continue;
-        }
-        if (canPublish !== void 0 && !canPublish(record.candidate)) continue;
-        record.candidate = Object.freeze({ ...record.candidate, state: "published" });
-        const receipt = Object.freeze({
-          candidateId: record.candidate.candidateId,
-          generation: record.candidate.generation,
-          revision: record.candidate.revision,
-          topologyRevision: record.candidate.topologyRevision,
-          ...record.candidate.fixedStep === void 0 ? {} : { fixedStep: record.candidate.fixedStep },
-          frameId: frame.frameId,
-          deviceGeneration: frame.deviceGeneration,
-          recordStageConsumed: canPublish !== void 0,
-          ...fixedStep === void 0 ? {} : { publicationFixedStep: fixedStep },
-          frame: Object.freeze({ ...frame })
-        });
-        receipts.push(receipt);
-        publishedReceipts.set(record.candidate.candidateId, receipt);
-        latestRevision = record.candidate.revision;
-        latestFrameId = frame.frameId;
-        if (!latestRevisionByWorld.has(record.world))
-          latestRevisionByWorld.set(record.world, /* @__PURE__ */ new Map());
-        latestRevisionByWorld.get(record.world)?.set(record.candidate.entity, record.candidate.revision);
-        if (!latestTopologyRevisionByWorld.has(record.world))
-          latestTopologyRevisionByWorld.set(record.world, /* @__PURE__ */ new Map());
-        latestTopologyRevisionByWorld.get(record.world)?.set(record.candidate.entity, record.candidate.topologyRevision);
-      }
-      return receipts;
-    },
-    invalidateWorld(world, completion) {
-      for (const [id, record] of records) {
-        if (record.world !== world) continue;
-        if (record.candidate.state === "cancelled" || record.candidate.state === "retired")
-          continue;
-        publishedReceipts.delete(id);
-        record.candidate = Object.freeze({ ...record.candidate, state: "cancelled" });
-        const release = () => {
-          if (records.get(id) !== record) return;
-          records.delete(id);
-          meshBytes = Math.max(0, meshBytes - record.candidate.meshBytes);
-        };
-        if (completion === void 0) release();
-        else void completion.then(release, release);
-        invalidated += 1;
-      }
-      latestRevisionByWorld.delete(world);
-      latestTopologyRevisionByWorld.delete(world);
-    },
-    invalidateGeneration(generation) {
-      if (generation === currentGeneration) return;
-      currentGeneration = generation;
-      const invalidatedWorlds = /* @__PURE__ */ new Set();
-      for (const [id, record] of records) {
-        if (record.candidate.generation !== generation) {
-          records.delete(id);
-          publishedReceipts.delete(id);
-          meshBytes = Math.max(0, meshBytes - record.candidate.meshBytes);
-          invalidatedWorlds.add(record.world);
-          invalidated += 1;
+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
+    );
+  }
+  const temporalIdentityFailure = input.temporal === void 0 ? void 0 : receiptFailure(input, input.temporal, "temporal");
+  if (temporalIdentityFailure !== void 0) return temporalIdentityFailure;
+  if (input.temporal !== void 0 && !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
         }
-      }
-      for (const world of invalidatedWorlds) {
-        latestRevisionByWorld.delete(world);
-        latestTopologyRevisionByWorld.delete(world);
-      }
-    },
-    receipt(candidate) {
-      const receipt = publishedReceipts.get(candidate.candidateId);
-      const record = records.get(candidate.candidateId);
-      if (record === void 0 || !sameCandidateCredential(candidate, record.candidate)) {
-        return void 0;
-      }
-      return receipt?.generation === candidate.generation ? receipt : void 0;
-    },
-    inspect() {
-      let prepared = 0;
-      let accepted = 0;
-      let published = 0;
-      for (const record of records.values()) {
-        if (record.candidate.state === "prepared") prepared += 1;
-        else if (record.candidate.state === "accepted") accepted += 1;
-        else if (record.candidate.state === "published") published += 1;
-      }
-      return Object.freeze({
-        generation: currentGeneration,
-        prepared,
-        accepted,
-        published,
-        retired,
-        ...latestRevision === void 0 ? {} : { latestRevision },
-        ...latestFrameId === void 0 ? {} : { latestFrameId },
-        historyInvalidations,
-        invalidated,
-        meshBytes,
-        maxMeshBytes
-      });
-    },
-    dispose() {
-      disposed = true;
-      records.clear();
-      publishedReceipts.clear();
-      meshBytes = 0;
-    }
+      ),
+      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
   };
 }
-function invalidStyle(input, component, field, value, expected) {
-  return err(new PointsLinesInvalidStyleError({ entity: input.entity, component, field, value, expected }));
+var ZERO_SPATIAL_WORK = Object.freeze({
+  attachmentCount: 0,
+  passCount: 0,
+  bindingCount: 0,
+  resourceCount: 0,
+  historyCount: 0,
+  temporalDemand: 0
+});
+var ADMITTED_SPATIAL_WORK = Object.freeze({
+  attachmentCount: 3,
+  passCount: 4,
+  bindingCount: 4,
+  resourceCount: 3,
+  historyCount: 0,
+  temporalDemand: 0
+});
+function configRange(field, viewRange, maxDistance) {
+  switch (field) {
+    case "maxDistance":
+      return { min: 0, minInclusive: false, max: viewRange, maxInclusive: true };
+    case "thickness":
+      return { min: 0, minInclusive: false, max: maxDistance, maxInclusive: true };
+    case "maxRoughness":
+      return { min: 0, minInclusive: true, max: 1, maxInclusive: true };
+  }
 }
-function topologyMismatch(input, submesh, expected, actual) {
-  return err(new PointsLinesTopologyMismatchError({ entity: input.entity, submesh, expected, actual }));
+function configError(field, value, range) {
+  const left = range.minInclusive ? "[" : "(";
+  const right = range.maxInclusive ? "]" : ")";
+  return Object.freeze({
+    code: "ssr-config-invalid",
+    expected: `finite ${field} in ${left}${range.min}, ${range.max}${right}`,
+    hint: `set ${field} to a finite value inside the reported range before retrying`,
+    detail: Object.freeze({ field, value, range: Object.freeze(range) })
+  });
 }
-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"
+function validateScreenSpaceReflection(config, input) {
+  const viewRange = input.viewRange;
+  if (!Number.isFinite(viewRange) || viewRange <= 0) {
+    return err(
+      configError("maxDistance", config.maxDistance, configRange("maxDistance", viewRange, 0))
     );
   }
-  if (!hasPoints && !hasLines) {
-    return invalidStyle(input, "Points/Lines", "components", void 0, "one style component");
+  if (!Number.isFinite(config.maxDistance) || config.maxDistance <= 0 || config.maxDistance > viewRange) {
+    return err(
+      configError(
+        "maxDistance",
+        config.maxDistance,
+        configRange("maxDistance", viewRange, config.maxDistance)
+      )
+    );
   }
-  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 });
+  if (!Number.isFinite(config.thickness) || config.thickness <= 0 || config.thickness > config.maxDistance) {
+    return err(
+      configError(
+        "thickness",
+        config.thickness,
+        configRange("thickness", viewRange, config.maxDistance)
+      )
+    );
   }
-  const widthPx = input.lines?.widthPx ?? 1;
-  if (!Number.isFinite(widthPx) || widthPx <= 0) {
-    return invalidStyle(input, "Lines", "widthPx", widthPx, "finite widthPx > 0");
+  if (!Number.isFinite(config.maxRoughness) || config.maxRoughness < 0 || config.maxRoughness > 1) {
+    return err(
+      configError(
+        "maxRoughness",
+        config.maxRoughness,
+        configRange("maxRoughness", viewRange, config.maxDistance)
+      )
+    );
   }
-  return ok({ component: "Lines", widthPx });
+  return ok(
+    Object.freeze({
+      maxDistance: config.maxDistance,
+      thickness: config.thickness,
+      maxRoughness: config.maxRoughness
+    })
+  );
 }
-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 unavailable(lane, reason, required, actual) {
+  const recovery = reason === "lane-unsupported" || reason === "projection-unsupported" ? "select a perspective clustered or deferred Standard lane" : reason === "reflection-fallback-unavailable" ? "repair the submitted reflection fallback owner receipt" : reason === "temporal-unavailable" ? "submit the matching temporal-v1 producer receipt" : reason === "recovery-unavailable" ? "complete device and producer recovery before retrying" : "restore the required scene, capability, or format input before retrying";
+  return Object.freeze({
+    code: "ssr-unavailable",
+    expected: "SSR spatial admission has a complete Standard input and capability set",
+    hint: recovery,
+    detail: Object.freeze({
+      lane,
+      reason,
+      required: Object.freeze([...required]),
+      actual: Object.freeze({ ...actual }),
+      recovery
+    })
+  });
 }
-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"
+function unavailableResult(lane, viewRange, failure2) {
+  return Object.freeze({
+    status: "fallback-only",
+    lane,
+    config: void 0,
+    viewRange,
+    work: ZERO_SPATIAL_WORK,
+    failure: failure2
+  });
+}
+function admitSsrSpatial(input) {
+  const camera = input.camera;
+  const environment = input.environment;
+  const viewRange = camera.far - camera.near;
+  const config = camera.screenSpaceReflection;
+  if (config === void 0) {
+    return Object.freeze({
+      status: "not-requested",
+      lane: environment.lane,
+      config: void 0,
+      viewRange,
+      work: ZERO_SPATIAL_WORK
+    });
+  }
+  const valid = validateScreenSpaceReflection(config, { viewRange });
+  if (!valid.ok) {
+    return Object.freeze({
+      status: "fallback-only",
+      lane: environment.lane,
+      config,
+      viewRange,
+      work: ZERO_SPATIAL_WORK,
+      failure: valid.error
+    });
+  }
+  if (environment.m0.status !== "admitted") {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(
+        environment.lane,
+        "reflection-fallback-unavailable",
+        ["admitted M0 dependency receipt"],
+        { m0: false }
+      )
+    );
+  }
+  if (environment.lane !== "clustered" && environment.lane !== "deferred") {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(environment.lane, "lane-unsupported", ["clustered or deferred Standard lane"], {
+        lane: environment.lane
       })
     );
   }
-  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"
+  if (camera.projection !== "perspective") {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(environment.lane, "projection-unsupported", ["perspective camera"], {
+        projection: camera.projection
       })
     );
   }
-  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 (!environment.sceneInputs) {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(
+        environment.lane,
+        "scene-input-unavailable",
+        ["deferred Standard scene/material/fallback inputs"],
+        { sceneInputs: false }
+      )
+    );
   }
-  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 (!environment.temporal) {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(environment.lane, "temporal-unavailable", ["temporal-v1"], { temporal: false })
+    );
+  }
+  if (!environment.reflectionFallback) {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(
+        environment.lane,
+        "reflection-fallback-unavailable",
+        ["submitted BRDF-projected fallback"],
+        { reflectionFallback: false }
+      )
+    );
+  }
+  if (environment.recovery === false) {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(environment.lane, "recovery-unavailable", ["ready device and owners"], {
+        recovery: false
+      })
+    );
+  }
+  const capabilities = environment.capabilities;
+  if (!capabilities.compute || !capabilities.storageTexture || !capabilities.rgba16floatRenderable) {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(
+        environment.lane,
+        "capability-unavailable",
+        ["compute", "storageTexture", "rgba16floatRenderable"],
+        {
+          compute: capabilities.compute,
+          storageTexture: capabilities.storageTexture,
+          rgba16floatRenderable: capabilities.rgba16floatRenderable
+        }
+      )
+    );
+  }
+  if (!capabilities.r32floatSampledStorage) {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(
+        environment.lane,
+        "format-unavailable",
+        ["r32float sampled and storage mip chain"],
+        { r32floatSampledStorage: false }
+      )
+    );
   }
-  return ok({ ...style.value, ...topology.value });
-}
-
-// 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
+    status: "admitted",
+    lane: environment.lane,
+    config: valid.value,
+    viewRange,
+    work: ADMITTED_SPATIAL_WORK
   });
 }
 
@@ -651,48 +646,6 @@ function inspectVolumetricFog(input) {
     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/reflection/filter.ts
 function createProbeFilterState(input) {
@@ -733,6 +686,9 @@ function normalize(vector) {
 }
 function boxProjectReflectionDirection(direction, boxCenter, halfExtents, point) {
   const ray = normalize(direction);
+  for (const axis of [0, 1, 2]) {
+    if (Math.abs(point[axis] - boxCenter[axis]) >= halfExtents[axis]) return ray;
+  }
   let distance = Number.POSITIVE_INFINITY;
   for (let axis = 0; axis < 3; axis += 1) {
     const component = ray[axis] ?? 0;
@@ -852,14 +808,14 @@ function validateReflectionProbeInput(input) {
       }
     };
   }
-  if (!Number.isInteger(input.resolution) || input.resolution <= 0) {
+  if (!Number.isInteger(input.resolution) || input.resolution < 16 || (input.resolution & input.resolution - 1) !== 0) {
     return {
       ok: false,
       error: {
         code: "reflection-probe-input-invalid",
         field: "resolution",
         value: input.resolution,
-        expected: "a positive integer"
+        expected: "a power of two of at least 16 pixels"
       }
     };
   }
@@ -868,11 +824,12 @@ function validateReflectionProbeInput(input) {
 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;
+  let filteredTexels = 0;
+  for (let mip = 0; mip < 5; mip++) {
+    const size = Math.max(1, Math.floor(clamped / 2 ** mip));
+    filteredTexels += size * size;
   }
-  return mipTexels * 6 * REFLECTION_PROBE_BYTES_PER_TEXEL;
+  return (clamped * clamped + 2 * filteredTexels) * 6 * REFLECTION_PROBE_BYTES_PER_TEXEL + 3 * clamped * clamped * 4;
 }
 function admitReflectionProbe(input, current, limits = DEFAULT_REFLECTION_PROBE_LIMITS) {
   const maxProbes = limits.maxProbes ?? DEFAULT_REFLECTION_PROBE_LIMITS.maxProbes;
@@ -1225,235 +1182,532 @@ function consumeLodOcclusionInspection(inspection) {
   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;
+
+// src/ssr/inspection.ts
+var SSR_INSPECTION_MAX_PASSES = 64;
+function nonNegativeSafeInteger(name, value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative safe integer`);
   }
-  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
-  });
+  return value;
 }
-function failure(code, owner, hint, detail = {}) {
-  const action = recoveryActionFor(code);
+function copyHistory(history) {
+  nonNegativeSafeInteger("SSR inspection history.bytes", history.bytes);
+  nonNegativeSafeInteger("SSR inspection history.resetCount", history.resetCount);
   return Object.freeze({
-    code,
-    expected: "all producer, format, and temporal receipts share one admitted identity",
-    hint,
-    detail: Object.freeze({ owner, action, ...detail })
+    state: history.state,
+    bytes: history.bytes,
+    resetCount: history.resetCount
   });
 }
-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 copyCoverage(coverage) {
+  const result = {
+    hitCount: coverage?.hitCount ?? null,
+    fallbackCount: coverage?.fallbackCount ?? null,
+    excludedCount: coverage?.excludedCount ?? null
+  };
+  for (const [key, value] of Object.entries(result)) {
+    if (value !== null) nonNegativeSafeInteger(`SSR inspection coverage.${key}`, value);
   }
+  return Object.freeze(result);
 }
-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 copyPassRoster(passRoster) {
+  return Object.freeze(
+    [...passRoster ?? []].slice(0, SSR_INSPECTION_MAX_PASSES).map((name, index) => {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new Error(`SSR inspection passRoster[${index}] must be a non-empty string`);
+      }
+      return name;
     })
   );
 }
-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 projectSsrSpatialInspection(admission, projection = {}) {
+  const config = admission.config;
+  return Object.freeze({
+    status: projection.status ?? admission.status,
+    lane: admission.lane,
+    config: config === void 0 ? void 0 : Object.freeze({
+      maxDistance: config.maxDistance,
+      thickness: config.thickness,
+      maxRoughness: config.maxRoughness
+    }),
+    viewRange: admission.viewRange,
+    coverage: copyCoverage(projection.coverage),
+    history: copyHistory(
+      projection.history ?? {
+        state: "not-owned",
+        bytes: 0,
+        resetCount: 0
+      }
+    ),
+    work: Object.freeze({ ...admission.work }),
+    passRoster: copyPassRoster(projection.passRoster),
+    fallbackSource: projection.fallbackSource,
+    failure: projection.failure ?? admission.failure
+  });
 }
-function validTemporal(receipt) {
-  return receipt?.successfulSubmit === true && Number.isInteger(receipt.generation) && receipt.generation >= 0;
+function serializeSsrSpatialInspection(inspection) {
+  return JSON.stringify(inspection);
 }
-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
-    );
+var DynamicGeometryError = class extends Error {
+  code;
+  expected;
+  hint;
+  detail;
+  constructor(code, expected, hint, detail = {}) {
+    super(`${code}: ${expected}`);
+    this.name = "DynamicGeometryError";
+    this.code = code;
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = Object.freeze({ code, ...detail });
   }
-  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
-    );
+};
+function sameCandidateCredential(candidate, committed) {
+  return candidate.candidateId === committed.candidateId && candidate.owner === committed.owner && candidate.world === committed.world && candidate.generation === committed.generation && candidate.entity === committed.entity && candidate.physicsEntity === committed.physicsEntity && candidate.gpuReady === committed.gpuReady && candidate.meshBytes === committed.meshBytes && candidate.revision === committed.revision && candidate.topologyRevision === committed.topologyRevision && candidate.materialIdentity === committed.materialIdentity && candidate.meshHandle === committed.meshHandle && candidate.fixedStep === committed.fixedStep;
+}
+function cloneTypedArray(value) {
+  return new value.constructor(value);
+}
+function cloneMesh(mesh) {
+  const attributes = Object.fromEntries(
+    Object.entries(mesh.attributes).map(([key, value]) => [
+      key,
+      value instanceof ArrayBuffer ? value.slice(0) : value === void 0 ? void 0 : cloneTypedArray(value)
+    ])
+  );
+  return Object.freeze({
+    ...mesh,
+    vertices: new Float32Array(mesh.vertices),
+    ...mesh.indices === void 0 ? {} : { indices: cloneTypedArray(mesh.indices) },
+    attributes,
+    ...mesh.aabb === void 0 ? {} : { aabb: new Float32Array(mesh.aabb) },
+    submeshes: Object.freeze(mesh.submeshes.map((submesh) => Object.freeze({ ...submesh }))),
+    materialSlots: Object.freeze(mesh.materialSlots.map((slot) => Object.freeze({ ...slot })))
+  });
+}
+function cloneCandidate(candidate) {
+  return Object.freeze({ ...candidate, mesh: cloneMesh(candidate.mesh) });
+}
+function validateMesh(mesh) {
+  if (mesh.kind !== "mesh") return "MeshAsset.kind must be mesh";
+  if (!(mesh.vertices instanceof Float32Array) || mesh.vertices.length === 0) {
+    return "MeshAsset.vertices must be a non-empty Float32Array";
   }
-  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 (mesh.indices !== void 0 && !(mesh.indices instanceof Uint16Array || mesh.indices instanceof Uint32Array)) {
+    return "MeshAsset.indices must be Uint16Array or Uint32Array";
   }
-  if (input.temporal === void 0) {
-    return blocked(
-      input.identity,
-      failure(
-        "ssr-temporal-unavailable",
-        "temporal",
-        "submit the matching temporal producer receipt"
-      ),
-      input.reflectionFallback.projectionGeneration
-    );
+  if (mesh.submeshes.length === 0)
+    return "MeshAsset.submeshes must contain at least one topology range";
+  if (mesh.submeshes.some(
+    (submesh) => !Number.isSafeInteger(submesh.materialSlot) || submesh.materialSlot < 0 || submesh.materialSlot >= mesh.materialSlots.length
+  )) {
+    return "MeshAsset.materialSlots must cover every referenced materialSlot";
   }
-  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 (mesh.vertices.some((value) => !Number.isFinite(value)))
+    return "MeshAsset.vertices must be finite";
+  return void 0;
+}
+function meshByteSize(mesh) {
+  let bytes = mesh.vertices.byteLength + (mesh.indices?.byteLength ?? 0);
+  for (const value of Object.values(mesh.attributes)) {
+    if (value instanceof ArrayBuffer) bytes += value.byteLength;
+    else if (value !== void 0 && ArrayBuffer.isView(value)) bytes += value.byteLength;
   }
-  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
+  if (mesh.aabb !== void 0) bytes += mesh.aabb.byteLength;
+  return bytes;
+}
+function createDynamicGeometryLifecycle(maxCandidates = 32, maxMeshBytes = 64 * 1024 * 1024) {
+  const records = /* @__PURE__ */ new Map();
+  const owner = {};
+  let sequence = 0;
+  let currentGeneration = 0;
+  let disposed = false;
+  let historyInvalidations = 0;
+  let latestRevision;
+  let latestFrameId;
+  let retired = 0;
+  let invalidated = 0;
+  let meshBytes = 0;
+  const latestRevisionByWorld = /* @__PURE__ */ new WeakMap();
+  const latestTopologyRevisionByWorld = /* @__PURE__ */ new WeakMap();
+  const publishedReceipts = /* @__PURE__ */ new Map();
+  const failure2 = (code, expected, hint, detail = {}) => err(new DynamicGeometryError(code, expected, hint, detail));
+  const current = (candidate) => {
+    const record = records.get(candidate.candidateId);
+    if (record === void 0 || candidate.owner !== owner || record.candidate.owner !== candidate.owner || record.candidate.world !== candidate.world || record.candidate.generation !== candidate.generation)
+      return void 0;
+    return record;
+  };
+  return {
+    prepare(input, generation) {
+      if (disposed)
+        return failure2("dynamic-geometry-disposed", "renderer is alive", "rebuild the Renderer");
+      if (input.world === null || typeof input.world !== "object") {
+        return failure2(
+          "dynamic-geometry-world-not-attached",
+          "candidate belongs to an attached World",
+          "attach the World before preparing geometry"
+        );
+      }
+      if (!Number.isInteger(input.revision) || input.revision < 0) {
+        return failure2(
+          "dynamic-geometry-invalid",
+          "geometry revision is a non-negative integer",
+          "advance the consumer revision monotonically",
+          { revision: input.revision }
+        );
+      }
+      if (generation !== currentGeneration && currentGeneration !== 0) {
+        return failure2(
+          "dynamic-geometry-generation-mismatch",
+          "candidate uses the active renderer generation",
+          "discard stale generation work and prepare again",
+          { generation, actual: currentGeneration }
+        );
+      }
+      if (records.size >= maxCandidates) {
+        return failure2(
+          "dynamic-geometry-budget-exceeded",
+          "candidate count remains within the bounded renderer budget",
+          "cancel or retire an earlier candidate before retrying",
+          { actual: records.size }
+        );
+      }
+      const invalid = validateMesh(input.mesh);
+      if (invalid !== void 0)
+        return failure2(
+          "dynamic-geometry-invalid",
+          "MeshAsset satisfies the standard geometry contract",
+          invalid
+        );
+      const candidateBytes = meshByteSize(input.mesh);
+      if (!Number.isSafeInteger(candidateBytes) || candidateBytes < 0 || meshBytes > maxMeshBytes - candidateBytes) {
+        return failure2(
+          "dynamic-geometry-budget-exceeded",
+          "candidate mesh bytes remain within the bounded renderer resource budget",
+          "cancel or retire an earlier candidate before retrying",
+          { actual: { meshBytes, candidateBytes, maxMeshBytes } }
+        );
+      }
+      const candidateId = `mesh:${generation}:${++sequence}:${input.revision}`;
+      const candidate = Object.freeze({
+        candidateId,
+        generation,
+        owner,
+        world: input.world,
+        ...input.entity === void 0 ? {} : { entity: input.entity },
+        ...input.physicsEntity === void 0 ? {} : { physicsEntity: input.physicsEntity },
+        gpuReady: input.meshHandle !== void 0,
+        meshBytes: candidateBytes,
+        revision: input.revision,
+        topologyRevision: input.topologyRevision ?? input.revision,
+        ...input.materialIdentity === void 0 ? {} : { materialIdentity: input.materialIdentity },
+        ...input.meshHandle === void 0 ? {} : { meshHandle: input.meshHandle },
+        ...input.fixedStep === void 0 ? {} : { fixedStep: input.fixedStep },
+        mesh: cloneMesh(input.mesh),
+        state: "prepared"
+      });
+      records.set(candidateId, {
+        world: input.world,
+        candidate,
+        historyInvalidated: false
+      });
+      meshBytes += candidateBytes;
+      currentGeneration = generation;
+      return ok(cloneCandidate(candidate));
+    },
+    accept(candidate, ordering) {
+      if (disposed)
+        return failure2("dynamic-geometry-disposed", "renderer is alive", "rebuild the Renderer");
+      const record = current(candidate);
+      if (record === void 0)
+        return failure2(
+          "dynamic-geometry-candidate-not-found",
+          "candidate is owned by this renderer",
+          "discard the stale credential"
+        );
+      if (candidate.generation !== currentGeneration) {
+        return failure2(
+          "dynamic-geometry-generation-mismatch",
+          "candidate generation matches the active renderer generation",
+          "prepare against the current renderer generation",
+          { candidateId: candidate.candidateId }
+        );
+      }
+      if (record.candidate.state !== "prepared") {
+        return failure2(
+          "dynamic-geometry-candidate-state",
+          "candidate is prepared exactly once before acceptance",
+          "retain the accepted or published receipt",
+          { candidateId: candidate.candidateId }
+        );
+      }
+      if (!sameCandidateCredential(candidate, record.candidate)) {
+        return failure2(
+          "dynamic-geometry-receipt-mismatch",
+          "acceptance uses the exact prepared candidate credential",
+          "discard the altered credential and use the value returned by prepare",
+          { candidateId: candidate.candidateId }
+        );
+      }
+      if (ordering !== void 0) {
+        if (ordering.world !== record.world || !Number.isInteger(ordering.fixedStep) || ordering.fixedStep < 0) {
+          return failure2(
+            "dynamic-geometry-ordering-required",
+            "acceptance ordering names the candidate World and a non-negative fixed step",
+            "submit the PhysicsWorld publication ordering for the same attached World",
+            { candidateId: candidate.candidateId, actual: ordering }
+          );
+        }
+      }
+      const newest = [...records.values()].filter(
+        (entry) => entry.candidate.candidateId !== candidate.candidateId && entry.world === record.world && entry.candidate.entity === record.candidate.entity && (entry.candidate.state === "prepared" || entry.candidate.state === "accepted")
+      ).map((entry) => entry.candidate.revision).concat(latestRevisionByWorld.get(record.world)?.get(record.candidate.entity) ?? -1).sort((a, b) => b - a)[0];
+      if (newest !== void 0 && record.candidate.revision <= newest) {
+        return failure2(
+          "dynamic-geometry-stale",
+          "accepted geometry revision is newer than the active candidate",
+          "advance topology revision before accepting",
+          { candidateId: candidate.candidateId }
+        );
+      }
+      const accepted = Object.freeze({
+        ...record.candidate,
+        ...ordering === void 0 ? {} : { fixedStep: ordering.fixedStep },
+        state: "accepted"
+      });
+      const previousTopologies = [...records.values()].filter(
+        (entry) => entry.candidate.candidateId !== candidate.candidateId && entry.world === record.world && entry.candidate.entity === record.candidate.entity
+      ).map((entry) => entry.candidate.topologyRevision);
+      const previousLatestTopology = latestTopologyRevisionByWorld.get(record.world)?.get(record.candidate.entity);
+      const newestTopology = previousTopologies.concat(previousLatestTopology === void 0 ? [] : [previousLatestTopology]).sort((a, b) => b - a)[0];
+      if (newestTopology !== void 0 && accepted.topologyRevision < newestTopology) {
+        return failure2(
+          "dynamic-geometry-stale",
+          "accepted topology revision is not older than the active geometry history",
+          "advance topology revision before accepting a replacement candidate",
+          { candidateId: candidate.candidateId }
+        );
+      }
+      if (newestTopology !== void 0 && accepted.topologyRevision > newestTopology) {
+        historyInvalidations += 1;
+        for (const previous of records.values()) {
+          if (previous.world !== record.world || previous.candidate.entity !== record.candidate.entity || previous.candidate.candidateId === candidate.candidateId || previous.candidate.topologyRevision >= accepted.topologyRevision)
+            continue;
+          if (!previous.historyInvalidated) {
+            previous.historyInvalidated = true;
+            invalidated += 1;
+          }
+        }
+      }
+      record.candidate = accepted;
+      return ok(cloneCandidate(accepted));
+    },
+    cancel(candidate, completion) {
+      const record = current(candidate);
+      if (record === void 0)
+        return failure2(
+          "dynamic-geometry-candidate-not-found",
+          "candidate is owned by this renderer",
+          "discard the stale credential"
+        );
+      if (!sameCandidateCredential(candidate, record.candidate))
+        return failure2(
+          "dynamic-geometry-receipt-mismatch",
+          "cancellation uses the exact prepared candidate credential",
+          "discard the altered credential and use the value returned by prepare",
+          { candidateId: candidate.candidateId }
+        );
+      if (record.candidate.state !== "prepared" && record.candidate.state !== "accepted") {
+        return failure2(
+          "dynamic-geometry-candidate-state",
+          "only prepared or accepted geometry can be cancelled once",
+          "retire published geometry or await the existing terminal cleanup"
+        );
+      }
+      record.candidate = Object.freeze({ ...record.candidate, state: "cancelled" });
+      const release = () => {
+        if (records.get(candidate.candidateId) !== record) return;
+        records.delete(candidate.candidateId);
+        meshBytes = Math.max(0, meshBytes - record.candidate.meshBytes);
+      };
+      if (completion === void 0) release();
+      else void completion.then(release, release);
+      return ok(void 0);
+    },
+    retire(candidate) {
+      const record = current(candidate);
+      if (record === void 0)
+        return failure2(
+          "dynamic-geometry-candidate-not-found",
+          "retirement uses a published candidate owned by this renderer",
+          "discard the stale credential and do not evict any unrelated mesh",
+          { candidateId: candidate.candidateId }
+        );
+      if (!sameCandidateCredential(candidate, record.candidate))
+        return failure2(
+          "dynamic-geometry-receipt-mismatch",
+          "retirement uses the exact published candidate credential",
+          "discard the altered credential and use the value returned by publish",
+          { candidateId: candidate.candidateId }
+        );
+      if (record.candidate.state !== "published") {
+        return failure2(
+          "dynamic-geometry-candidate-state",
+          "only published geometry can enter receipt-bound retirement",
+          "publish the candidate from a submitted frame first"
+        );
+      }
+      record.candidate = Object.freeze({ ...record.candidate, state: "retired" });
+      publishedReceipts.delete(candidate.candidateId);
+      retired += 1;
+      return ok(void 0);
+    },
+    finalizeRetirement(candidate) {
+      const record = current(candidate);
+      if (record === void 0)
+        return failure2(
+          "dynamic-geometry-candidate-not-found",
+          "retirement finalization uses a candidate retained by this lifecycle",
+          "discard the stale credential or finish the current receipt-bound retirement"
+        );
+      if (!sameCandidateCredential(candidate, record.candidate))
+        return failure2(
+          "dynamic-geometry-receipt-mismatch",
+          "retirement finalization uses the exact published candidate credential",
+          "discard the altered credential and use the value returned by publication",
+          { candidateId: candidate.candidateId }
+        );
+      if (record.candidate.state !== "retired")
+        return failure2(
+          "dynamic-geometry-candidate-state",
+          "only a retired candidate can release its deferred budget",
+          "retire the published candidate before finalizing its receipt-bound cleanup",
+          { candidateId: candidate.candidateId }
+        );
+      records.delete(candidate.candidateId);
+      meshBytes = Math.max(0, meshBytes - record.candidate.meshBytes);
+      return ok(void 0);
+    },
+    publishFrame(frame, worlds, fixedStep, canPublish) {
+      if (disposed || frame.deviceGeneration !== currentGeneration) return [];
+      const receipts = [];
+      for (const record of records.values()) {
+        const canRepeatPublished = record.candidate.state === "published" && // Attached Renderer publication revalidates the entity binding in
+        // `canPublish`, so a history-invalidated candidate can still record
+        // a real draw for its live entity. Detached lifecycle publication
+        // remains one-shot once that history is invalidated.
+        (canPublish !== void 0 || !record.historyInvalidated);
+        if (record.candidate.state !== "accepted" && !canRepeatPublished) continue;
+        if (worlds !== void 0 && !worlds.includes(record.world)) continue;
+        if (record.candidate.fixedStep !== void 0 && (fixedStep === void 0 || record.candidate.fixedStep > fixedStep)) {
+          continue;
         }
-      ),
-      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
+        if (canPublish !== void 0 && !canPublish(record.candidate)) continue;
+        record.candidate = Object.freeze({ ...record.candidate, state: "published" });
+        const receipt = Object.freeze({
+          candidateId: record.candidate.candidateId,
+          generation: record.candidate.generation,
+          revision: record.candidate.revision,
+          topologyRevision: record.candidate.topologyRevision,
+          ...record.candidate.fixedStep === void 0 ? {} : { fixedStep: record.candidate.fixedStep },
+          frameId: frame.frameId,
+          deviceGeneration: frame.deviceGeneration,
+          recordStageConsumed: canPublish !== void 0,
+          ...fixedStep === void 0 ? {} : { publicationFixedStep: fixedStep },
+          frame: Object.freeze({ ...frame })
+        });
+        receipts.push(receipt);
+        publishedReceipts.set(record.candidate.candidateId, receipt);
+        latestRevision = record.candidate.revision;
+        latestFrameId = frame.frameId;
+        if (!latestRevisionByWorld.has(record.world))
+          latestRevisionByWorld.set(record.world, /* @__PURE__ */ new Map());
+        latestRevisionByWorld.get(record.world)?.set(record.candidate.entity, record.candidate.revision);
+        if (!latestTopologyRevisionByWorld.has(record.world))
+          latestTopologyRevisionByWorld.set(record.world, /* @__PURE__ */ new Map());
+        latestTopologyRevisionByWorld.get(record.world)?.set(record.candidate.entity, record.candidate.topologyRevision);
+      }
+      return receipts;
+    },
+    invalidateWorld(world, completion) {
+      for (const [id, record] of records) {
+        if (record.world !== world) continue;
+        if (record.candidate.state === "cancelled" || record.candidate.state === "retired")
+          continue;
+        publishedReceipts.delete(id);
+        record.candidate = Object.freeze({ ...record.candidate, state: "cancelled" });
+        const release = () => {
+          if (records.get(id) !== record) return;
+          records.delete(id);
+          meshBytes = Math.max(0, meshBytes - record.candidate.meshBytes);
+        };
+        if (completion === void 0) release();
+        else void completion.then(release, release);
+        invalidated += 1;
+      }
+      latestRevisionByWorld.delete(world);
+      latestTopologyRevisionByWorld.delete(world);
+    },
+    invalidateGeneration(generation) {
+      if (generation === currentGeneration) return;
+      currentGeneration = generation;
+      const invalidatedWorlds = /* @__PURE__ */ new Set();
+      for (const [id, record] of records) {
+        if (record.candidate.generation !== generation) {
+          records.delete(id);
+          publishedReceipts.delete(id);
+          meshBytes = Math.max(0, meshBytes - record.candidate.meshBytes);
+          invalidatedWorlds.add(record.world);
+          invalidated += 1;
+        }
+      }
+      for (const world of invalidatedWorlds) {
+        latestRevisionByWorld.delete(world);
+        latestTopologyRevisionByWorld.delete(world);
+      }
+    },
+    receipt(candidate) {
+      const receipt = publishedReceipts.get(candidate.candidateId);
+      const record = records.get(candidate.candidateId);
+      if (record === void 0 || !sameCandidateCredential(candidate, record.candidate)) {
+        return void 0;
+      }
+      return receipt?.generation === candidate.generation ? receipt : void 0;
+    },
+    inspect() {
+      let prepared = 0;
+      let accepted = 0;
+      let published = 0;
+      for (const record of records.values()) {
+        if (record.candidate.state === "prepared") prepared += 1;
+        else if (record.candidate.state === "accepted") accepted += 1;
+        else if (record.candidate.state === "published") published += 1;
+      }
+      return Object.freeze({
+        generation: currentGeneration,
+        prepared,
+        accepted,
+        published,
+        retired,
+        ...latestRevision === void 0 ? {} : { latestRevision },
+        ...latestFrameId === void 0 ? {} : { latestFrameId },
+        historyInvalidations,
+        invalidated,
+        meshBytes,
+        maxMeshBytes
+      });
+    },
+    dispose() {
+      disposed = true;
+      records.clear();
+      publishedReceipts.clear();
+      meshBytes = 0;
+    }
   };
 }
 
-export { DEFAULT_REFLECTION_PROBE_LIMITS, DynamicGeometryError, 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, createDynamicGeometryLifecycle, createProbeFilterState, deriveReflectionFallbackProjection, estimateReflectionProbeBytes, inspectLodOcclusion, inspectPointShadow, inspectReflectionFallback, inspectVolumetricFog, probeFilterIsSteady, projectSsrDependencies, reflectionFallbackCoverage, reflectionFallbackProjectionSignature, reflectionFallbackSourceKey, reflectionProbeTableBytes, resolveReflectionFallbackSource, resolveSsrAdmissionGeneration, sameCandidateCredential, selectReflectionProbe, serializeLodOcclusionInspection, validateReflectionProbeInput, zeroSsrAdmissionWork };
-//# sourceMappingURL=chunk-J52NMQKR.mjs.map
-//# sourceMappingURL=chunk-J52NMQKR.mjs.map
+export { DEFAULT_REFLECTION_PROBE_LIMITS, DynamicGeometryError, LOD_OCCLUSION_INSPECTION_MAX_BYTES, LOD_OCCLUSION_INSPECTION_SCHEMA, ReflectionProbeProjection, SSR_FORMAT_PROFILE, SSR_FORMAT_STAGES, admitPointsLines, admitReflectionProbe, admitSsrM0, admitSsrSpatial, advanceProbeFilter, boxProjectReflectionDirection, buildReflectionProbeTable, commitProbeFilterStep, consumeLodOcclusionInspection, createDynamicGeometryLifecycle, createProbeFilterState, deriveReflectionFallbackProjection, estimateReflectionProbeBytes, inspectLodOcclusion, inspectPointShadow, inspectReflectionFallback, inspectVolumetricFog, probeFilterIsSteady, projectSsrDependencies, projectSsrSpatialInspection, reflectionFallbackCoverage, reflectionFallbackProjectionSignature, reflectionFallbackSourceKey, reflectionProbeTableBytes, resolveReflectionFallbackSource, resolveSsrAdmissionGeneration, sameCandidateCredential, selectReflectionProbe, serializeLodOcclusionInspection, serializeSsrSpatialInspection, validateReflectionProbeInput, validateScreenSpaceReflection, zeroSsrAdmissionWork };
+//# sourceMappingURL=chunk-7MQ3XBSP.mjs.map
+//# sourceMappingURL=chunk-7MQ3XBSP.mjs.map