@forgeax/engine-render 0.1.27 → 0.1.29

package/dist/{chunk-KM2NOX2I.mjs → chunk-BQVQOQJH.mjs}

@@ -1,7 +1,6 @@
-import { CUBE_CAMERA_FACE_ORDER, createVisibilityBudget, PointShapeValue, pointShapeFromU32 } from './chunk-ADHHVYLW.mjs';
-import { PointsLinesBudgetExceededError, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-ZZ4YQ474.mjs';
+import { PointShapeValue, pointShapeFromU32 } from './chunk-33XZFTQU.mjs';
+import { PointsLinesBudgetExceededError, createVisibilityBudget, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-NRNXBLIJ.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) {
@@ -163,6 +162,458 @@ function inspectPointShadow(snapshots, shadowAtlasCapacity) {
     shadowAtlasCapacity
   });
 }
+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
+    );
+  }
+  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
+        }
+      ),
+      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
+  };
+}
+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 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 validateScreenSpaceReflection(config, input) {
+  const viewRange = input.viewRange;
+  if (!Number.isFinite(viewRange) || viewRange <= 0) {
+    return err(
+      configError("maxDistance", config.maxDistance, configRange("maxDistance", viewRange, 0))
+    );
+  }
+  if (!Number.isFinite(config.maxDistance) || config.maxDistance <= 0 || config.maxDistance > viewRange) {
+    return err(
+      configError(
+        "maxDistance",
+        config.maxDistance,
+        configRange("maxDistance", viewRange, config.maxDistance)
+      )
+    );
+  }
+  if (!Number.isFinite(config.thickness) || config.thickness <= 0 || config.thickness > config.maxDistance) {
+    return err(
+      configError(
+        "thickness",
+        config.thickness,
+        configRange("thickness", viewRange, config.maxDistance)
+      )
+    );
+  }
+  if (!Number.isFinite(config.maxRoughness) || config.maxRoughness < 0 || config.maxRoughness > 1) {
+    return err(
+      configError(
+        "maxRoughness",
+        config.maxRoughness,
+        configRange("maxRoughness", viewRange, config.maxDistance)
+      )
+    );
+  }
+  return ok(
+    Object.freeze({
+      maxDistance: config.maxDistance,
+      thickness: config.thickness,
+      maxRoughness: config.maxRoughness
+    })
+  );
+}
+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 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
+      })
+    );
+  }
+  if (camera.projection !== "perspective") {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(environment.lane, "projection-unsupported", ["perspective camera"], {
+        projection: camera.projection
+      })
+    );
+  }
+  if (!environment.sceneInputs) {
+    return unavailableResult(
+      environment.lane,
+      viewRange,
+      unavailable(
+        environment.lane,
+        "scene-input-unavailable",
+        ["deferred Standard scene/material/fallback inputs"],
+        { sceneInputs: false }
+      )
+    );
+  }
+  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 Object.freeze({
+    status: "admitted",
+    lane: environment.lane,
+    config: valid.value,
+    viewRange,
+    work: ADMITTED_SPATIAL_WORK
+  });
+}
 
 // src/volume/inspection.ts
 function resourceStage(input) {
@@ -195,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) {
@@ -769,235 +1178,530 @@ 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 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 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;
+function serializeSsrSpatialInspection(inspection) {
+  return JSON.stringify(inspection);
+}
+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 });
   }
-  return validateR32FloatReceipt(receipt).ok;
+};
+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 validTemporal(receipt) {
-  return receipt?.successfulSubmit === true && Number.isInteger(receipt.generation) && receipt.generation >= 0;
+function cloneTypedArray(value) {
+  return new value.constructor(value);
 }
-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
-    );
-  }
+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({
-    status: "admitted",
-    identity: input.identity,
-    generation: input.reflectionFallback.projectionGeneration,
-    work: ADMITTED_WORK,
-    budget: ADMITTED_BUDGET
+    ...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 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 cloneCandidate(candidate) {
+  return Object.freeze({ ...candidate, mesh: cloneMesh(candidate.mesh) });
 }
-function zeroSsrAdmissionWork() {
-  return ZERO_WORK;
+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";
+  }
+  if (mesh.vertices.some((value) => !Number.isFinite(value)))
+    return "MeshAsset.vertices must be finite";
+  return void 0;
 }
-function resolveSsrAdmissionGeneration(previousGeneration, nextGeneration) {
+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 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 {
-    changed: previousGeneration !== void 0 && nextGeneration !== void 0 && previousGeneration !== nextGeneration,
-    generation: nextGeneration
+    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;
+        }
+      }
+      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, 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-KM2NOX2I.mjs.map
-//# sourceMappingURL=chunk-KM2NOX2I.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-BQVQOQJH.mjs.map
+//# sourceMappingURL=chunk-BQVQOQJH.mjs.map