@forgeax/engine-render 0.1.33 → 0.1.34

package/dist/chunk-NNQL7CB3.mjs

@@ -1,1713 +0,0 @@
-import { PointShapeValue, pointShapeFromU32 } from './chunk-PLAXOOX5.mjs';
-import { PointsLinesBudgetExceededError, createVisibilityBudget, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-NB2S7ZRX.mjs';
-import { err, ok } from '@forgeax/engine-types';
-import { validateR32FloatReceipt } from '@forgeax/engine-rhi';
-
-function invalidStyle(input, component, field, value, expected) {
-  return err(new PointsLinesInvalidStyleError({ entity: input.entity, component, field, value, expected }));
-}
-function topologyMismatch(input, submesh, expected, actual) {
-  return err(new PointsLinesTopologyMismatchError({ entity: input.entity, submesh, expected, actual }));
-}
-function checkStyle(input) {
-  const hasPoints = input.points !== void 0;
-  const hasLines = input.lines !== void 0;
-  if (hasPoints && hasLines) {
-    return invalidStyle(
-      input,
-      "Points/Lines",
-      "components",
-      "Points + Lines",
-      "exactly one style component"
-    );
-  }
-  if (!hasPoints && !hasLines) {
-    return invalidStyle(input, "Points/Lines", "components", void 0, "one style component");
-  }
-  if (hasPoints) {
-    const sizePx = input.points?.sizePx ?? 4;
-    const shapeValue = input.points?.shape ?? PointShapeValue.square;
-    const shape = pointShapeFromU32(shapeValue);
-    if (!Number.isFinite(sizePx) || sizePx <= 0) {
-      return invalidStyle(input, "Points", "sizePx", sizePx, "finite sizePx > 0");
-    }
-    if (shape === void 0) {
-      return invalidStyle(input, "Points", "shape", shapeValue, "shape is 'square' or 'circle'");
-    }
-    return ok({ component: "Points", shape, sizePx });
-  }
-  const widthPx = input.lines?.widthPx ?? 1;
-  if (!Number.isFinite(widthPx) || widthPx <= 0) {
-    return invalidStyle(input, "Lines", "widthPx", widthPx, "finite widthPx > 0");
-  }
-  return ok({ component: "Lines", widthPx });
-}
-function checkTopology(input, component) {
-  const expected = component === "Points" ? "point-list" : "line-list";
-  let pointCount = 0;
-  let segmentCount = 0;
-  const acceptedSubmeshes = [];
-  let sawNonEmpty = false;
-  for (const [submeshIndex, submesh] of input.mesh.submeshes.entries()) {
-    const indexed = input.mesh.indices !== void 0 && submesh.indexCount > 0;
-    const elementCount = indexed ? submesh.indexCount : submesh.vertexCount;
-    if (elementCount === 0) continue;
-    sawNonEmpty = true;
-    if (component === "Lines" && submesh.topology === "line-strip") {
-      return err(
-        new PointsLinesStyleUnsupportedError({
-          lane: "admission",
-          field: "topology",
-          member: "line-strip",
-          supported: ["line-list"]
-        })
-      );
-    }
-    if (submesh.topology !== expected) {
-      return topologyMismatch(input, submeshIndex, expected, submesh.topology);
-    }
-    if (component === "Lines" && elementCount % 2 !== 0) {
-      return topologyMismatch(input, submeshIndex, "line-list pairs", "line-list odd tail");
-    }
-    acceptedSubmeshes.push(submeshIndex);
-    if (component === "Points") pointCount += elementCount;
-    else segmentCount += elementCount / 2;
-  }
-  if (!sawNonEmpty) return topologyMismatch(input, 0, expected, "empty-range");
-  return ok({ pointCount, segmentCount, submeshes: acceptedSubmeshes });
-}
-function checkMaterial(input) {
-  const passes = input.material.passes ?? [];
-  const unlitModules = /* @__PURE__ */ new Set(["forgeax_material::unlit", "forgeax::default-unlit"]);
-  if (passes.length !== 1 || passes[0] === void 0) {
-    const pass2 = passes.find(
-      (candidate) => candidate.name === "deferred" || candidate.name === "shadow-caster"
-    ) ?? passes[0];
-    return err(
-      new PointsLinesMaterialUnsupportedError({
-        entity: input.entity,
-        material: input.materialId ?? "<anonymous>",
-        pass: pass2?.name ?? "<empty>",
-        module: pass2?.program.module ?? "<empty>",
-        reason: "points-lines admission requires one unlit forward pass"
-      })
-    );
-  }
-  const pass = passes[0];
-  const lightMode = pass.renderState?.tags?.LightMode;
-  if (!unlitModules.has(pass.program.module) || pass.name !== "forward" || lightMode === "ShadowCaster") {
-    return err(
-      new PointsLinesMaterialUnsupportedError({
-        entity: input.entity,
-        material: input.materialId ?? "<anonymous>",
-        pass: pass.name,
-        module: pass.program.module,
-        reason: "points-lines admission requires an engine-owned unlit forward pass"
-      })
-    );
-  }
-  return ok(void 0);
-}
-function admitPointsLines(input) {
-  const style = checkStyle(input);
-  if (!style.ok) return style;
-  const topology = checkTopology(input, style.value.component);
-  if (!topology.ok) return topology;
-  const material = checkMaterial(input);
-  if (!material.ok) return material;
-  if (style.value.component === "Points" && input.limits?.maxPoints !== void 0) {
-    if (topology.value.pointCount > input.limits.maxPoints) {
-      return err(
-        new PointsLinesBudgetExceededError({
-          lane: "admission",
-          requested: topology.value.pointCount,
-          limit: input.limits.maxPoints,
-          unit: "points"
-        })
-      );
-    }
-  }
-  if (style.value.component === "Lines" && input.limits?.maxSegments !== void 0) {
-    if (topology.value.segmentCount > input.limits.maxSegments) {
-      return err(
-        new PointsLinesBudgetExceededError({
-          lane: "admission",
-          requested: topology.value.segmentCount,
-          limit: input.limits.maxSegments,
-          unit: "segments"
-        })
-      );
-    }
-  }
-  return ok({ ...style.value, ...topology.value });
-}
-
-// 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
-  });
-}
-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) {
-  if (!input.authored || input.recovery === void 0) return "none";
-  if (input.recovery.status === "candidate") return "candidate";
-  if (input.recovery.status === "recovering") return "recovering";
-  if (input.recovery.status === "degraded") return "lkg";
-  return "accepted";
-}
-function inspectVolumetricFog(input) {
-  const recovery = input.recovery;
-  const status = !input.authored ? "off" : input.capability === "unavailable" ? "unavailable" : input.degraded === true || recovery?.status === "degraded" ? "degraded" : "available";
-  return Object.freeze({
-    status,
-    resourceStage: resourceStage(input),
-    guid: recovery?.guid,
-    generation: recovery?.generation,
-    digest: input.acceptedDigest,
-    candidateGeneration: recovery?.candidateGeneration,
-    candidateDigest: recovery?.candidateDigest,
-    lkgGeneration: recovery?.lkgGeneration,
-    candidateFailure: recovery?.candidateFailure,
-    deviceEpoch: recovery?.deviceEpoch ?? 0,
-    format: input.format,
-    passCount: input.passCount ?? 0,
-    sampleCount: input.sampleCount ?? 0,
-    memoryBytes: input.memoryBytes ?? 0,
-    resourceFacts: input.resourceFacts,
-    selectedLight: recovery?.selectedLight,
-    candidateSelectedLight: recovery?.candidateSelectedLight
-  });
-}
-
-// src/reflection/filter.ts
-function createProbeFilterState(input) {
-  return {
-    probeIndex: input.probeIndex,
-    faceCount: input.faceCount ?? 6,
-    mipCount: input.mipCount,
-    cursor: 0,
-    activeGeneration: input.activeGeneration ?? 0
-  };
-}
-function advanceProbeFilter(state) {
-  const total = state.faceCount * state.mipCount;
-  if (state.cursor >= total) return void 0;
-  return {
-    probeIndex: state.probeIndex,
-    faceIndex: state.cursor % state.faceCount,
-    mipLevel: Math.floor(state.cursor / state.faceCount)
-  };
-}
-function commitProbeFilterStep(state, success) {
-  if (!success) return state;
-  const nextCursor = state.cursor + 1;
-  const complete = nextCursor >= state.faceCount * state.mipCount;
-  return {
-    ...state,
-    cursor: nextCursor,
-    activeGeneration: complete ? state.activeGeneration + 1 : state.activeGeneration
-  };
-}
-function probeFilterIsSteady(state) {
-  return state.cursor >= state.faceCount * state.mipCount;
-}
-function normalize(vector) {
-  const length = Math.hypot(vector[0], vector[1], vector[2]);
-  if (length === 0) return [0, 0, 1];
-  return [vector[0] / length, vector[1] / length, vector[2] / length];
-}
-function boxProjectReflectionDirection(direction, boxCenter, halfExtents, point) {
-  const ray = normalize(direction);
-  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;
-    if (component === 0) continue;
-    const extent = halfExtents[axis] ?? 0;
-    const edge = component > 0 ? (boxCenter[axis] ?? 0) + extent : (boxCenter[axis] ?? 0) - extent;
-    const candidate = (edge - (point[axis] ?? 0)) / component;
-    if (candidate > 0) distance = Math.min(distance, candidate);
-  }
-  if (!Number.isFinite(distance)) return ray;
-  return normalize([
-    (point[0] ?? 0) + ray[0] * distance - (boxCenter[0] ?? 0),
-    (point[1] ?? 0) + ray[1] * distance - (boxCenter[1] ?? 0),
-    (point[2] ?? 0) + ray[2] * distance - (boxCenter[2] ?? 0)
-  ]);
-}
-
-// src/reflection/gpu-table.ts
-function buildReflectionProbeTable(rows) {
-  const ordered = rows.slice().sort((a, b) => a.index - b.index);
-  const indices = /* @__PURE__ */ new Map();
-  for (const row of ordered) {
-    if (row.primitiveKey !== void 0) indices.set(row.primitiveKey, row.index);
-  }
-  const indexFor = (primitiveKey2) => indices.get(primitiveKey2);
-  return {
-    rows: Object.freeze(ordered),
-    cpuIndexByPrimitive: indexFor,
-    gpuIndexByPrimitive: indexFor
-  };
-}
-function reflectionProbeTableBytes(table) {
-  return table.rows.length * 48;
-}
-
-// src/reflection/inspection.ts
-function recoveryFor(receipt, failure2) {
-  if (failure2 !== void 0) {
-    const code = failure2.code.toLowerCase();
-    if (code.includes("device") || code.includes("format") || code.includes("capability")) {
-      return "rebuild";
-    }
-    if (failure2.stage === "prepare" || failure2.stage === "filter") return "recapture";
-    if (failure2.stage === "build" || failure2.stage === "encode") return "rebuild";
-    if (failure2.stage === "finish" || failure2.stage === "submit") return "retry";
-    if (failure2.stage === "completion") {
-      if (receipt.source === "probe" && (receipt.state === "active" || receipt.state === "lkg")) {
-        return "use-LKG";
-      }
-      if (receipt.source === "skylight" && (receipt.state === "active" || receipt.state === "lkg")) {
-        return "use-Skylight";
-      }
-      if (receipt.source === "neutral" && receipt.state === "neutral") return "use-neutral";
-      return "retry";
-    }
-  }
-  if (receipt.source === "probe" && (receipt.state === "active" || receipt.state === "lkg")) {
-    return "use-LKG";
-  }
-  if (receipt.source === "skylight" || receipt.state === "lkg") return "use-Skylight";
-  return "use-neutral";
-}
-function inspectReflectionFallback(receipt, failure2) {
-  return {
-    receipt,
-    recoveryAction: recoveryFor(receipt, failure2),
-    ...failure2 === void 0 ? {} : {
-      failureStage: failure2.stage,
-      failureCode: failure2.code,
-      expected: failure2.expected,
-      ...failure2.detail === void 0 ? {} : { detail: failure2.detail }
-    }
-  };
-}
-
-// src/reflection/projection.ts
-var REFLECTION_PROBE_BYTES_PER_TEXEL = 8;
-var DEFAULT_REFLECTION_PROBE_LIMITS = Object.freeze({
-  maxProbes: 16,
-  maxResolution: 256,
-  maxBytes: 64 * 1024 * 1024
-});
-function validateReflectionProbeInput(input) {
-  for (let index = 0; index < input.halfExtents.length; index += 1) {
-    const value = input.halfExtents[index];
-    if (value === void 0 || !Number.isFinite(value) || value <= 0) {
-      return {
-        ok: false,
-        error: {
-          code: "reflection-probe-input-invalid",
-          field: `halfExtents[${index}]`,
-          value,
-          expected: "a finite number greater than zero"
-        }
-      };
-    }
-  }
-  if (!Number.isFinite(input.priority)) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-probe-input-invalid",
-        field: "priority",
-        value: input.priority,
-        expected: "a finite number"
-      }
-    };
-  }
-  if (!Number.isFinite(input.intensity) || input.intensity < 0) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-probe-input-invalid",
-        field: "intensity",
-        value: input.intensity,
-        expected: "a finite number greater than or equal to zero"
-      }
-    };
-  }
-  if (!Number.isInteger(input.resolution) || input.resolution < 16 || (input.resolution & input.resolution - 1) !== 0) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-probe-input-invalid",
-        field: "resolution",
-        value: input.resolution,
-        expected: "a power of two of at least 16 pixels"
-      }
-    };
-  }
-  return { ok: true };
-}
-function estimateReflectionProbeBytes(resolution, limits = DEFAULT_REFLECTION_PROBE_LIMITS) {
-  const maxResolution = limits.maxResolution ?? DEFAULT_REFLECTION_PROBE_LIMITS.maxResolution;
-  const clamped = Math.min(resolution, maxResolution);
-  let filteredTexels = 0;
-  for (let mip = 0; mip < 5; mip++) {
-    const size = Math.max(1, Math.floor(clamped / 2 ** mip));
-    filteredTexels += size * size;
-  }
-  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;
-  const maxBytes = limits.maxBytes ?? DEFAULT_REFLECTION_PROBE_LIMITS.maxBytes;
-  const maxResolution = limits.maxResolution ?? DEFAULT_REFLECTION_PROBE_LIMITS.maxResolution;
-  const requested = estimateReflectionProbeBytes(input.resolution, { maxResolution });
-  if (input.resolution > maxResolution || current.acceptedCount >= maxProbes || current.acceptedBytes + requested > maxBytes) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-probe-budget-exceeded",
-        requested,
-        activeCount: current.acceptedCount,
-        activeBytes: current.acceptedBytes,
-        maxProbes,
-        maxBytes
-      }
-    };
-  }
-  return { ok: true, acceptedBytes: current.acceptedBytes + requested };
-}
-function resolveReflectionFallbackSource(selection, probeReady, skylightAvailable = true) {
-  if (selection.kind === "probe" && probeReady) return "probe";
-  if (skylightAvailable) return "skylight";
-  return "neutral";
-}
-function reflectionFallbackCoverage(source, fact, selection) {
-  if (source === "neutral") return 0;
-  if (source === "skylight") return 1;
-  if (fact === void 0 || selection.kind !== "probe") return 0;
-  const normalized = Math.sqrt(Math.max(0, selection.normalizedDistance));
-  return Math.max(0, Math.min(1, 1 - normalized / Math.sqrt(3)));
-}
-function reflectionFallbackSourceKey(source, selection, skylight) {
-  if (source === "probe" && selection.kind === "probe") {
-    return `probe:${selection.worldId}:${selection.entityKey}`;
-  }
-  if (source === "skylight" && skylight !== void 0) {
-    return `skylight:${skylight.entityHandle}:${skylight.equirectHandle}`;
-  }
-  return source;
-}
-function reflectionFallbackProjectionSignature(input) {
-  return JSON.stringify({
-    renderableKey: input.renderableKey,
-    sourceKey: input.sourceKey,
-    source: input.source,
-    coverage: input.coverage,
-    extent: input.extent,
-    brdfSignature: input.brdfSignature
-  });
-}
-function deriveReflectionFallbackProjection(input) {
-  if (!Number.isFinite(input.coverage) || input.coverage < 0 || input.coverage > 1) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-fallback-input-invalid",
-        field: "coverage",
-        expected: "a finite number between zero and one"
-      }
-    };
-  }
-  if (input.extent?.some((value) => !Number.isFinite(value) || value <= 0)) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-fallback-input-invalid",
-        field: "extent",
-        expected: "three finite numbers greater than zero"
-      }
-    };
-  }
-  if (input.linearHdr.some((value) => !Number.isFinite(value))) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-fallback-input-invalid",
-        field: "linearHdr",
-        expected: "four finite linear HDR values"
-      }
-    };
-  }
-  if (input.brdfSignature.length === 0) {
-    return {
-      ok: false,
-      error: {
-        code: "reflection-fallback-input-invalid",
-        field: "brdfSignature",
-        expected: "a non-empty BRDF signature"
-      }
-    };
-  }
-  const linearHdr = input.source === "neutral" ? [0, 0, 0, 0] : [...input.linearHdr];
-  return {
-    ok: true,
-    value: Object.freeze({
-      ...input.renderableKey === void 0 ? {} : { renderableKey: input.renderableKey },
-      ...input.sourceKey === void 0 ? {} : { sourceKey: input.sourceKey },
-      source: input.source,
-      coverage: input.coverage,
-      ...input.extent === void 0 ? {} : {
-        extent: Object.freeze([...input.extent])
-      },
-      linearHdr: Object.freeze(linearHdr),
-      brdfSignature: input.brdfSignature
-    })
-  };
-}
-function contains(fact, point) {
-  return fact.halfExtents.every((extent, axis) => {
-    const center = fact.center[axis] ?? 0;
-    const coordinate = point[axis] ?? 0;
-    return Math.abs(coordinate - center) <= extent;
-  });
-}
-function normalizedDistance(fact, point) {
-  let squared = 0;
-  for (let axis = 0; axis < 3; axis += 1) {
-    const delta = (point[axis] ?? 0) - (fact.center[axis] ?? 0);
-    const extent = fact.halfExtents[axis] ?? 1;
-    squared += (delta / extent) ** 2;
-  }
-  return squared;
-}
-function isBetter(candidate, current, facts) {
-  const candidateFact = facts.find(
-    (fact) => fact.worldId === candidate.worldId && fact.entityKey === candidate.entityKey
-  );
-  const currentFact = facts.find(
-    (fact) => fact.worldId === current.worldId && fact.entityKey === current.entityKey
-  );
-  if (candidateFact === void 0 || currentFact === void 0) return false;
-  if (candidateFact.priority !== currentFact.priority)
-    return candidateFact.priority > currentFact.priority;
-  if (candidate.normalizedDistance !== current.normalizedDistance) {
-    return candidate.normalizedDistance < current.normalizedDistance;
-  }
-  return candidate.worldId < current.worldId || candidate.worldId === current.worldId && candidate.entityKey < current.entityKey;
-}
-function selectReflectionProbe(facts, primitiveCenter) {
-  let selected;
-  for (const fact of facts) {
-    if (!contains(fact, primitiveCenter)) continue;
-    const candidate = {
-      kind: "probe",
-      worldId: fact.worldId,
-      entityKey: fact.entityKey,
-      normalizedDistance: normalizedDistance(fact, primitiveCenter)
-    };
-    if (selected === void 0 || isBetter(candidate, selected, facts)) selected = candidate;
-  }
-  return selected ?? { kind: "skylight" };
-}
-function primitiveKey(worldId, entityKey) {
-  return `${worldId}:${entityKey}`;
-}
-var ReflectionProbeProjection = class {
-  revision = 0;
-  facts = [];
-  selected = /* @__PURE__ */ new Map();
-  signature = "";
-  scannedPrimitives = 0;
-  update(facts, primitives) {
-    const nextFacts = facts.slice().sort((a, b) => a.worldId - b.worldId || a.entityKey - b.entityKey);
-    const signature = JSON.stringify({ facts: nextFacts, primitives });
-    if (signature === this.signature) return this.snapshot();
-    this.signature = signature;
-    this.facts = nextFacts;
-    this.selected = /* @__PURE__ */ new Map();
-    for (const primitive of primitives) {
-      this.selected.set(
-        primitive.renderableKey ?? primitiveKey(primitive.worldId, primitive.entityKey),
-        selectReflectionProbe(nextFacts, primitive.center)
-      );
-    }
-    this.scannedPrimitives = primitives.length;
-    this.revision += 1;
-    return this.snapshot();
-  }
-  snapshot() {
-    return {
-      revision: this.revision,
-      facts: this.facts,
-      selected: this.selected,
-      scannedPrimitives: this.scannedPrimitives
-    };
-  }
-  selection(worldId, entityKey) {
-    return this.selected.get(primitiveKey(worldId, entityKey)) ?? { kind: "skylight" };
-  }
-};
-
-// src/scene/visibility/inspection.ts
-var LOD_OCCLUSION_INSPECTION_SCHEMA = "forgeax::lod-occlusion-inspection::v2";
-var LOD_OCCLUSION_INSPECTION_MAX_BYTES = 16 * 1024;
-var MAX_INSPECTION_SAMPLES = 64;
-function nonNegativeInteger(name, value) {
-  if (!Number.isInteger(value) || value < 0)
-    throw new Error(`${name} must be a non-negative integer`);
-  return value;
-}
-function copyError(error) {
-  return Object.freeze({
-    code: error.code,
-    expected: error.expected,
-    hint: error.hint,
-    ...error.detail === void 0 ? {} : { detail: Object.freeze({ ...error.detail }) }
-  });
-}
-function copyFallback(fallback) {
-  return fallback.active ? Object.freeze({ ...fallback, error: copyError(fallback.error) }) : Object.freeze({ active: false });
-}
-function copySamples(samples) {
-  return Object.freeze(
-    [...samples].sort((left, right) => left.primitiveSlot - right.primitiveSlot).slice(0, MAX_INSPECTION_SAMPLES).map(
-      (sample) => Object.freeze({
-        primitiveSlot: nonNegativeInteger("sample.primitiveSlot", sample.primitiveSlot),
-        level: nonNegativeInteger("sample.level", sample.level),
-        visible: sample.visible
-      })
-    )
-  );
-}
-function copyWorldAttribution(attribution) {
-  if (attribution === void 0) {
-    return Object.freeze({ status: "unavailable", reason: "projection-only" });
-  }
-  if (attribution.status === "same-submit") {
-    if (typeof attribution.submit.build !== "string" || attribution.submit.build.length === 0) {
-      throw new Error("world.attribution.submit.build must be a non-empty string");
-    }
-    nonNegativeInteger("world.attribution.submit.frameId", attribution.submit.frameId);
-    nonNegativeInteger(
-      "world.attribution.submit.deviceGeneration",
-      attribution.submit.deviceGeneration
-    );
-    return Object.freeze({
-      status: "same-submit",
-      submit: Object.freeze({ ...attribution.submit })
-    });
-  }
-  if (attribution.status !== "unavailable" || attribution.reason !== "projection-only") {
-    throw new Error("world.attribution must declare same-submit or projection-only");
-  }
-  return Object.freeze({ status: "unavailable", reason: "projection-only" });
-}
-function copyRow(row) {
-  for (const [name, value] of Object.entries({
-    generation: row.generation,
-    candidates: row.count.candidates,
-    visible: row.count.visible,
-    occluded: row.count.occluded,
-    median: row.queryLatencyUs.median,
-    p95: row.queryLatencyUs.p95,
-    last: row.queryLatencyUs.last,
-    pageUsed: row.pagePressure.used,
-    pageCapacity: row.pagePressure.capacity
-  }))
-    nonNegativeInteger(`inspection.${name}`, value);
-  if (row.view.cameraEntity < 0 || row.view.viewGeneration < 0 || row.slot.primitiveSlot < 0 || row.slot.slotGeneration < 0) {
-    throw new Error("inspection identity values must be non-negative");
-  }
-  if (row.pagePressure.used > row.pagePressure.capacity) {
-    throw new Error("inspection page pressure exceeds capacity");
-  }
-  return Object.freeze({
-    root: Object.freeze({ ...row.root }),
-    view: Object.freeze({ ...row.view }),
-    slot: Object.freeze({ ...row.slot }),
-    generation: row.generation,
-    count: Object.freeze({ ...row.count }),
-    lodHistogram: Object.freeze(
-      row.lodHistogram.map(
-        (histogram) => Object.freeze({
-          level: nonNegativeInteger("histogram.level", histogram.level),
-          count: nonNegativeInteger("histogram.count", histogram.count)
-        })
-      )
-    ),
-    queryLatencyUs: Object.freeze({ ...row.queryLatencyUs }),
-    pagePressure: Object.freeze({ ...row.pagePressure }),
-    fallback: copyFallback(row.fallback),
-    degradation: Object.freeze({ ...row.degradation }),
-    samples: copySamples(row.samples)
-  });
-}
-function copyWorlds(worlds, fallback) {
-  const source = worlds ?? [{ attachmentId: fallback.view.attachmentId, rows: [fallback] }];
-  return Object.freeze(
-    source.map(
-      (world) => Object.freeze({
-        attachmentId: world.attachmentId,
-        rows: Object.freeze(world.rows.map((row) => copyRow(row))),
-        attribution: copyWorldAttribution(world.attribution)
-      })
-    )
-  );
-}
-function inspectLodOcclusion(input) {
-  const row = copyRow(input);
-  const defaultBudget = createVisibilityBudget();
-  const budget = input.budget ?? {
-    configuredQueryBudget: defaultBudget.configuredQueryBudget,
-    effectiveQueryBudget: defaultBudget.effectiveQueryBudget,
-    settleSubmits: defaultBudget.settleSubmits,
-    retestSubmits: defaultBudget.retestSubmits,
-    expirySubmits: defaultBudget.expirySubmits
-  };
-  for (const [name, value] of Object.entries(budget))
-    nonNegativeInteger(`inspection.budget.${name}`, value);
-  const submit = input.submit ?? {
-    frameId: input.generation,
-    build: "unknown",
-    deviceGeneration: 0
-  };
-  nonNegativeInteger("inspection.submit.frameId", submit.frameId);
-  nonNegativeInteger("inspection.submit.deviceGeneration", submit.deviceGeneration);
-  if (typeof submit.build !== "string" || submit.build.length === 0) {
-    throw new Error("inspection.submit.build must be a non-empty string");
-  }
-  const worlds = copyWorlds(input.worlds, row);
-  for (const world of worlds) {
-    if (world.attribution.status === "same-submit" && (world.attribution.submit.frameId !== submit.frameId || world.attribution.submit.build !== submit.build || world.attribution.submit.deviceGeneration !== submit.deviceGeneration)) {
-      throw new Error("world attribution must reference the parent inspection submit");
-    }
-  }
-  const inspection = Object.freeze({
-    schema: LOD_OCCLUSION_INSPECTION_SCHEMA,
-    ...row,
-    submit: Object.freeze({ ...submit }),
-    budget: Object.freeze({ ...budget }),
-    worlds
-  });
-  if (JSON.stringify(inspection).length > LOD_OCCLUSION_INSPECTION_MAX_BYTES) {
-    throw new Error(`LOD occlusion inspection exceeds ${LOD_OCCLUSION_INSPECTION_MAX_BYTES} bytes`);
-  }
-  return inspection;
-}
-function serializeLodOcclusionInspection(inspection) {
-  const serialized = JSON.stringify(inspection);
-  if (serialized.length > LOD_OCCLUSION_INSPECTION_MAX_BYTES) {
-    throw new Error(`LOD occlusion inspection exceeds ${LOD_OCCLUSION_INSPECTION_MAX_BYTES} bytes`);
-  }
-  return serialized;
-}
-function consumeLodOcclusionInspection(inspection) {
-  if (!inspection.fallback.active) return { action: "none" };
-  const { reason, error } = inspection.fallback;
-  const action = error.code.startsWith("asset-") || reason === "producer-failed" ? "rebuild" : reason === "query-failed" || reason === "page-exhausted" || reason === "device-loss" ? "retry" : "cold-cook";
-  return { action, sourceKey: inspection.root.sourceKey, reason };
-}
-
-// 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 value;
-}
-function copyHistory(history) {
-  nonNegativeSafeInteger("SSR inspection history.bytes", history.bytes);
-  nonNegativeSafeInteger("SSR inspection history.resetCount", history.resetCount);
-  return Object.freeze({
-    state: history.state,
-    bytes: history.bytes,
-    resetCount: history.resetCount
-  });
-}
-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 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 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 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 });
-  }
-};
-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";
-  }
-  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.submeshes.some(
-    (submesh) => !Number.isSafeInteger(submesh.materialSlot) || submesh.materialSlot < 0 || submesh.materialSlot >= mesh.materialSlots.length
-  )) {
-    return "MeshAsset.materialSlots must cover every referenced materialSlot";
-  }
-  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 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;
-        }
-      }
-      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, 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-NNQL7CB3.mjs.map
-//# sourceMappingURL=chunk-NNQL7CB3.mjs.map