@forgeax/engine-render 0.1.28 → 0.1.30

package/dist/{chunk-J6KACNOH.mjs → chunk-JRBDO2KB.mjs}

@@ -1,4 +1,118 @@
 import { cubeArrayDepthDescriptor, comparisonSamplerDescriptor, cubeArrayDepthFaceView } from '@forgeax/engine-rhi';
+import { err, ok } from '@forgeax/engine-types';
+
+// src/pipeline/standard-output/auto-exposure/inspection.ts
+var AutoExposureInvalidParameterError = class extends Error {
+  constructor(detail) {
+    super(`auto-exposure-invalid-parameter: ${detail.field}`);
+    this.detail = detail;
+    this.name = "AutoExposureInvalidParameterError";
+  }
+  detail;
+  code = "auto-exposure-invalid-parameter";
+  expected = ERROR_POLICY[this.code].expected;
+  hint = ERROR_POLICY[this.code].hint;
+};
+var AutoExposureCapabilityUnavailableError = class extends Error {
+  constructor(detail) {
+    super(`auto-exposure-capability-unavailable: ${detail.capability}`);
+    this.detail = detail;
+    this.name = "AutoExposureCapabilityUnavailableError";
+  }
+  detail;
+  code = "auto-exposure-capability-unavailable";
+  expected = ERROR_POLICY[this.code].expected;
+  hint = ERROR_POLICY[this.code].hint;
+};
+var AutoExposureStaleGenerationError = class extends Error {
+  constructor(detail) {
+    super(
+      `auto-exposure-stale-generation: ${detail.actualGeneration} != ${detail.expectedGeneration}`
+    );
+    this.detail = detail;
+    this.name = "AutoExposureStaleGenerationError";
+  }
+  detail;
+  code = "auto-exposure-stale-generation";
+  expected = ERROR_POLICY[this.code].expected;
+  hint = ERROR_POLICY[this.code].hint;
+};
+var AutoExposureStageFailedError = class extends Error {
+  constructor(detail) {
+    super(`auto-exposure-stage-failed: ${detail.operation}`);
+    this.detail = detail;
+    this.name = "AutoExposureStageFailedError";
+  }
+  detail;
+  code = "auto-exposure-stage-failed";
+  expected = ERROR_POLICY[this.code].expected;
+  hint = ERROR_POLICY[this.code].hint;
+};
+var ERROR_POLICY = {
+  "auto-exposure-invalid-parameter": {
+    expected: "camera auto-exposure parameters are finite and within their declared ranges",
+    hint: "inspect the field and provide a finite value before rebuilding the camera output"
+  },
+  "auto-exposure-capability-unavailable": {
+    expected: "the auto-exposure stage has the required device capability",
+    hint: "inspect live capabilities and retry the same camera generation"
+  },
+  "auto-exposure-stale-generation": {
+    expected: "the prepared auto-exposure state matches the camera target generation",
+    hint: "discard stale prepared state and rebuild from the latest camera snapshot"
+  },
+  "auto-exposure-stage-failed": {
+    expected: "the auto-exposure stage completes its declared operation",
+    hint: "inspect the structured cause, preserve lastKnownGood, and retry the stage"
+  }
+};
+function createAutoExposureError(input) {
+  if (input instanceof AutoExposureInvalidParameterError || input instanceof AutoExposureCapabilityUnavailableError || input instanceof AutoExposureStaleGenerationError || input instanceof AutoExposureStageFailedError) {
+    return input;
+  }
+  switch (input.code) {
+    case "auto-exposure-invalid-parameter":
+      return new AutoExposureInvalidParameterError(input.detail);
+    case "auto-exposure-capability-unavailable":
+      return new AutoExposureCapabilityUnavailableError(input.detail);
+    case "auto-exposure-stale-generation":
+      return new AutoExposureStaleGenerationError(input.detail);
+    case "auto-exposure-stage-failed":
+      return new AutoExposureStageFailedError(input.detail);
+  }
+}
+function cloneExposure(exposure) {
+  if (exposure.kind === "manual") return { ...exposure };
+  return {
+    ...exposure,
+    rangeEv: [exposure.rangeEv[0], exposure.rangeEv[1]],
+    rates: [exposure.rates[0], exposure.rates[1]]
+  };
+}
+function cloneFailure(error) {
+  if (error === void 0) return void 0;
+  return Object.freeze({
+    ...error,
+    detail: Object.freeze({ ...error.detail })
+  });
+}
+function createAutoExposureInspection(input) {
+  const base = {
+    requested: cloneExposure(input.requested),
+    actual: input.actual,
+    actualState: input.actualState ?? (input.actual === null ? "gpu-resident" : "accepted"),
+    fallback: input.fallback,
+    lastKnownGood: input.lastKnownGood,
+    targetGeneration: input.targetGeneration,
+    reset: Object.freeze([...input.reset]),
+    cost: Object.freeze({ ...input.cost }),
+    receipt: Object.freeze({ ...input.receipt })
+  };
+  if (input.recentFailure === void 0) return Object.freeze(base);
+  const recentFailure = cloneFailure(createAutoExposureError(input.recentFailure));
+  if (recentFailure === void 0) return Object.freeze(base);
+  return Object.freeze({ ...base, recentFailure });
+}
 
 // src/errors/render.ts
 var LifecycleConstructionError = class extends Error {
@@ -259,16 +373,16 @@ var MaterialSkinAttrMissingError = class extends Error {
   expected;
   hint;
   detail;
-  constructor(entity, missing) {
+  constructor(entity, missing2) {
     const expected = "pbr-skin material requires mesh.attributes.skinIndex + skinWeight";
-    const hint = `entity ${entity} uses forgeax::pbr-skin but its MeshAsset is missing ${missing}; switch the entity to a skinned glTF mesh authored with JOINTS_0 + WEIGHTS_0, or change the material to a non-skin shader via Materials.standard / Materials.unlit`;
+    const hint = `entity ${entity} uses forgeax::pbr-skin but its MeshAsset is missing ${missing2}; switch the entity to a skinned glTF mesh authored with JOINTS_0 + WEIGHTS_0, or change the material to a non-skin shader via Materials.standard / Materials.unlit`;
     super(
-      `material/skin attribute mismatch on entity ${entity}: pbr-skin material with mesh missing ${missing}`
+      `material/skin attribute mismatch on entity ${entity}: pbr-skin material with mesh missing ${missing2}`
     );
     this.name = "MaterialSkinAttrMissingError";
     this.expected = expected;
     this.hint = hint;
-    this.detail = { entity, missing };
+    this.detail = { entity, missing: missing2 };
   }
 };
 var TransmissionCapabilityMissingError = class extends Error {
@@ -512,6 +626,41 @@ var AtmosphereInvalidParameterError = class extends Error {
     this.hint = `set Atmosphere.${field} to a finite value ${rangeText}`;
   }
 };
+var DynamicResolutionInvalidParameterError = class extends Error {
+  code = "dynamic-resolution-invalid-parameter";
+  expected;
+  hint;
+  detail;
+  constructor(detail) {
+    super(`DynamicResolution.${detail.field} is invalid`);
+    this.name = "DynamicResolutionInvalidParameterError";
+    this.expected = `DynamicResolution.${detail.field} must be ${detail.expected}`;
+    this.hint = `set DynamicResolution.${detail.field} to a value that is ${detail.expected}`;
+    this.detail = detail;
+  }
+};
+var DynamicResolutionRequiresTaaError = class extends Error {
+  code = "dynamic-resolution-requires-taa";
+  expected = "DynamicResolution requires Camera.antialias to be 'taa'";
+  hint = "set Camera.antialias to 'taa' or remove DynamicResolution before retrying";
+  detail;
+  constructor(detail) {
+    super("DynamicResolution requires TAA");
+    this.name = "DynamicResolutionRequiresTaaError";
+    this.detail = detail;
+  }
+};
+var DynamicResolutionTimingUnavailableError = class extends Error {
+  code = "dynamic-resolution-timing-unavailable";
+  expected = "adaptive resolution receives a completed GPU timing sample";
+  hint = "use fixed minScale=maxScale or retry after timestamp support is available";
+  detail;
+  constructor(detail) {
+    super(`DynamicResolution timing is unavailable for generation ${detail.generation}`);
+    this.name = "DynamicResolutionTimingUnavailableError";
+    this.detail = detail;
+  }
+};
 var OwnerStageFailedError = class extends Error {
   code = "owner-stage-failed";
   expected = "the owner completes its current frame stage";
@@ -778,6 +927,7 @@ var VolumeInvalidParametersError = class extends Error {
 var GPU_TEXTURE_USAGE_COPY_SRC = 1;
 var GPU_TEXTURE_USAGE_COPY_DST = 2;
 var GPU_TEXTURE_USAGE_TEXTURE_BINDING = 4;
+var GPU_TEXTURE_USAGE_STORAGE_BINDING = 8;
 var GPU_TEXTURE_USAGE_RENDER_ATTACHMENT = 16;
 var GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING = GPU_TEXTURE_USAGE_RENDER_ATTACHMENT | GPU_TEXTURE_USAGE_TEXTURE_BINDING;
 
@@ -929,6 +1079,461 @@ var ShadowAtlas = class {
   }
 };
 
+// src/errors/gpu-driven.ts
+var ERROR_POLICY2 = {
+  "missing-material-receipt": {
+    expected: "a producer-owned material program receipt is present",
+    hint: "cook and load the selected material program artifact, then retry preparation",
+    recovery: "rebuild-producer"
+  },
+  "material-abi-not-executable": {
+    expected: "the published material ABI fits the GPU Scene submission layout",
+    hint: "recook the material with a scene-index ABI supported by the GPU-driven owner or keep it on its authored lane",
+    recovery: "route-cpu-lane"
+  },
+  "missing-uv": {
+    expected: "the geometry exposes every UV set named by the material receipt",
+    hint: "repair the geometry UV semantic or route the draw to the CPU semantic lane",
+    recovery: "route-cpu-lane"
+  },
+  "reflection-mismatch": {
+    expected: "the loaded reflection receipt matches the artifact layout identity",
+    hint: "rebuild the material artifact and reflection from one source, then retry",
+    recovery: "rebuild-producer"
+  },
+  "vertex-input-mismatch": {
+    expected: "geometry vertex semantics match the material reflection receipt",
+    hint: "repair the geometry vertex semantic layout or route the draw to the CPU lane",
+    recovery: "route-cpu-lane"
+  },
+  "alpha-mask-mismatch": {
+    expected: "the Alpha Mask cutoff is present in the material receipt",
+    hint: "declare the pass coverage cutoff in the material schema and recook it",
+    recovery: "rebuild-producer"
+  },
+  "resource-not-ready": {
+    expected: "all material resource slots have resolved handles",
+    hint: "resolve the declared texture and sampler resources before recording",
+    recovery: "retry-same-draw"
+  },
+  "stale-generation": {
+    expected: "receipt and prepared inputs belong to the requested generation",
+    hint: "discard stale GPU facts, rebuild the producer receipt, and retry the same draw",
+    recovery: "rebuild-generation"
+  },
+  "skin-receipt-mismatch": {
+    expected: "skinned geometry has a current palette address receipt",
+    hint: "rebuild the Skin palette receipt for this generation before recording",
+    recovery: "rebuild-producer"
+  },
+  "shadow-ownership": {
+    expected: "every declared ShadowCaster pass has one GPU-compatible draw-item owner",
+    hint: "repair the ShadowCaster producer membership or keep the residual on its explicit CPU lane",
+    recovery: "route-cpu-lane"
+  }
+};
+var GpuDrivenPreparationError = class extends Error {
+  code;
+  expected;
+  hint;
+  detail;
+  constructor(code, detail) {
+    const policy = ERROR_POLICY2[code];
+    super(`[GpuDrivenPreparationError ${code}] ${policy.expected}`);
+    this.name = "GpuDrivenPreparationError";
+    this.code = code;
+    this.expected = policy.expected;
+    this.hint = policy.hint;
+    this.detail = Object.freeze({
+      ...detail,
+      recovery: detail.recovery ?? policy.recovery
+    });
+  }
+};
+var MATRIX_STRIDE = 16;
+var INITIAL_CAPACITY = 1;
+function instanceUploadRangesForResident(activeIsNew, dirtyRanges, fullRange) {
+  return activeIsNew ? [fullRange] : dirtyRanges;
+}
+function instanceCollectionFailureFacts(cause, recovery, requestedBytes = 0, supportedBytes = void 0, backend = "unknown") {
+  return {
+    requestedBytes,
+    supportedBytes,
+    backend,
+    owner: "renderer.instances",
+    cause,
+    recovery
+  };
+}
+var InstanceCollectionError = class extends Error {
+  code;
+  expected;
+  hint;
+  detail;
+  owner = "renderer.instances";
+  recovery;
+  facts;
+  constructor(code, expected, hint, detail, facts) {
+    super(`${code}: ${expected}`);
+    this.name = "InstanceCollectionError";
+    this.code = code;
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = detail;
+    this.facts = facts ?? instanceCollectionFailureFacts(
+      code,
+      hint,
+      detail?.operation === "create" || detail?.operation === "replace" ? typeof detail.actual === "number" && Number.isFinite(detail.actual) ? detail.actual * Float32Array.BYTES_PER_ELEMENT : 0 : 0
+    );
+    this.recovery = this.facts.recovery;
+  }
+};
+function nextCapacity(required) {
+  let capacity = INITIAL_CAPACITY;
+  while (capacity < required) capacity *= 2;
+  return capacity;
+}
+function invalid(operation, expected, actual, collectionId, context) {
+  const hint = "repair the collection payload and retry the same authoring operation";
+  return new InstanceCollectionError(
+    "instance-collection-invalid",
+    expected,
+    hint,
+    { operation, expected, actual, ...collectionId === void 0 ? {} : { collectionId } },
+    instanceCollectionFailureFacts(
+      context?.cause ?? `invalid-${operation}-authoring`,
+      context?.recovery ?? hint,
+      context?.requestedBytes ?? 0,
+      context?.supportedBytes
+    )
+  );
+}
+function validateTransforms(operation, transforms, collectionId) {
+  if (!(transforms instanceof Float32Array)) {
+    return invalid(operation, "transforms is a Float32Array", typeof transforms, collectionId, {
+      cause: "invalid-transform-type"
+    });
+  }
+  if (transforms.length % MATRIX_STRIDE !== 0) {
+    return invalid(
+      operation,
+      `transforms.length is a multiple of ${MATRIX_STRIDE}`,
+      transforms.length,
+      collectionId,
+      {
+        requestedBytes: transforms.byteLength,
+        cause: "invalid-transform-stride"
+      }
+    );
+  }
+  for (const value of transforms) {
+    if (!Number.isFinite(value)) {
+      return invalid(operation, "every transform value is finite", value, collectionId, {
+        requestedBytes: transforms.byteLength,
+        cause: "invalid-transform-value"
+      });
+    }
+  }
+  return void 0;
+}
+function appendRange(ranges, start, end) {
+  if (start >= end) return;
+  let index = 0;
+  while (index < ranges.length) {
+    const existing = ranges[index];
+    if (existing === void 0 || existing.end >= start) break;
+    index += 1;
+  }
+  while (index < ranges.length) {
+    const existing = ranges[index];
+    if (existing === void 0 || existing.start > end) break;
+    start = Math.min(start, existing.start);
+    end = Math.max(end, existing.end);
+    ranges.splice(index, 1);
+  }
+  ranges.splice(index, 0, { start, end });
+}
+function appendDirtyRange(record, start, end) {
+  appendRange(record.dirtyRanges, start, end);
+}
+function missing(operation, id) {
+  return new InstanceCollectionError(
+    "instance-collection-not-found",
+    `instance collection ${Number(id)} is live and owned by this Renderer`,
+    "create a collection with renderer.instances.create or retain the original collection id",
+    { operation, expected: "a live instance collection id", actual: Number(id), collectionId: id }
+  );
+}
+var InstanceCollectionStore = class {
+  nextId = 1;
+  epochValue = 0;
+  disposed = false;
+  records = /* @__PURE__ */ new Map();
+  residency = /* @__PURE__ */ new Map();
+  get epoch() {
+    return this.epochValue;
+  }
+  create(input) {
+    if (this.disposed) {
+      return err(
+        new InstanceCollectionError(
+          "instance-collection-released",
+          "the Renderer-owned instance collection store is live",
+          "create a new Renderer before authoring instance collections"
+        )
+      );
+    }
+    const invalidPayload = validateTransforms("create", input.transforms);
+    if (invalidPayload !== void 0) return err(invalidPayload);
+    const id = this.nextId++;
+    const count = input.transforms.length / MATRIX_STRIDE;
+    const record = {
+      id,
+      transforms: new Float32Array(input.transforms),
+      count,
+      capacity: nextCapacity(Math.max(INITIAL_CAPACITY, count)),
+      revision: 1,
+      dirtyRanges: count === 0 ? [] : [{ start: 0, end: count }],
+      lastSnapshotRevision: 0,
+      released: false
+    };
+    this.records.set(id, record);
+    this.epochValue += 1;
+    return ok(this.info(record));
+  }
+  replace(id, transforms) {
+    const record = this.live("replace", id);
+    if (!record.ok) return record;
+    const invalidPayload = validateTransforms("replace", transforms, id);
+    if (invalidPayload !== void 0) return err(invalidPayload);
+    const count = transforms.length / MATRIX_STRIDE;
+    record.value.transforms = new Float32Array(transforms);
+    record.value.count = count;
+    record.value.capacity = Math.max(record.value.capacity, nextCapacity(Math.max(1, count)));
+    record.value.revision += 1;
+    record.value.dirtyRanges = count === 0 ? [] : [{ start: 0, end: count }];
+    record.value.lastSnapshotRevision = record.value.revision - 1;
+    this.epochValue += 1;
+    return ok(this.info(record.value));
+  }
+  update(id, input) {
+    const record = this.live("update", id);
+    if (!record.ok) return record;
+    const invalidPayload = validateTransforms("update", input.transforms, id);
+    if (invalidPayload !== void 0) return err(invalidPayload);
+    if (!Number.isInteger(input.start) || input.start < 0) {
+      return err(
+        invalid("update", "start is a non-negative matrix ordinal", input.start, id, {
+          requestedBytes: input.transforms.byteLength,
+          supportedBytes: record.value.capacity * MATRIX_STRIDE * Float32Array.BYTES_PER_ELEMENT,
+          cause: "invalid-update-range-start"
+        })
+      );
+    }
+    const span = input.transforms.length / MATRIX_STRIDE;
+    const attemptedEnd = input.start + span;
+    if (attemptedEnd > record.value.count) {
+      return err(
+        invalid(
+          "update",
+          `start + matrix count is <= collection count (${record.value.count})`,
+          attemptedEnd,
+          id,
+          {
+            requestedBytes: attemptedEnd * MATRIX_STRIDE * Float32Array.BYTES_PER_ELEMENT,
+            supportedBytes: record.value.count * MATRIX_STRIDE * Float32Array.BYTES_PER_ELEMENT,
+            cause: "invalid-update-range-end"
+          }
+        )
+      );
+    }
+    if (record.value.lastSnapshotRevision === record.value.revision) {
+      record.value.dirtyRanges = [];
+    }
+    record.value.transforms.set(input.transforms, input.start * MATRIX_STRIDE);
+    record.value.revision += 1;
+    appendDirtyRange(record.value, input.start, input.start + span);
+    this.epochValue += 1;
+    return ok(this.info(record.value));
+  }
+  inspect(id) {
+    const record = this.live("inspect", id);
+    return record.ok ? ok(this.info(record.value)) : record;
+  }
+  /**
+   * Return detached residency facts for every live collection.
+   *
+   * @internal Record-stage evidence is reported through the two methods below;
+   * callers only receive immutable PODs and never GPU handles.
+   */
+  _inspections() {
+    return Object.freeze(
+      [...this.records.values()].map((record) => this.projectInspection(record))
+    );
+  }
+  /** @internal Renderer record owner reports the accepted collection lane. */
+  _reportResidency(input) {
+    if (!this.records.has(input.collectionId)) return;
+    const previous = this.residency.get(input.collectionId);
+    const sameFrame = previous !== void 0 && previous.frameNumber === input.frameNumber && previous.error === void 0;
+    const uploadRanges = sameFrame ? [...previous.uploadRanges].reduce(
+      (ranges, range) => {
+        appendRange(ranges, range.start, range.end);
+        return ranges;
+      },
+      input.uploadRanges.map((range) => ({ ...range }))
+    ) : input.uploadRanges.map((range) => ({ ...range }));
+    this.residency.set(input.collectionId, {
+      frameNumber: input.frameNumber,
+      residentGeneration: input.residentGeneration,
+      lane: input.lane,
+      uploadRanges,
+      uploadedBytes: sameFrame ? previous.uploadedBytes + input.uploadedBytes : input.uploadedBytes,
+      requestedBytes: input.requestedBytes,
+      supportedBytes: input.supportedBytes,
+      backend: input.backend,
+      error: void 0
+    });
+  }
+  /** @internal Renderer record owner reports a typed admission failure. */
+  _reportFailure(input) {
+    if (!this.records.has(input.collectionId)) return;
+    this.residency.set(input.collectionId, {
+      frameNumber: -1,
+      residentGeneration: void 0,
+      lane: "unavailable",
+      uploadRanges: [],
+      uploadedBytes: 0,
+      requestedBytes: input.facts.requestedBytes,
+      supportedBytes: input.facts.supportedBytes,
+      backend: input.facts.backend,
+      error: {
+        code: input.code,
+        expected: input.expected,
+        hint: input.hint,
+        detail: { ...input.facts }
+      }
+    });
+  }
+  /** @internal A lost device invalidates every renderer-owned GPU resident. */
+  _resetResidency() {
+    this.residency.clear();
+  }
+  snapshot(id) {
+    const record = this.live("inspect", id);
+    if (!record.ok) return record;
+    const value = record.value;
+    value.lastSnapshotRevision = value.revision;
+    const result = {
+      ...this.info(value),
+      transforms: new Float32Array(value.transforms),
+      dirtyRanges: value.dirtyRanges.map((range) => ({ ...range }))
+    };
+    return ok(result);
+  }
+  release(id) {
+    const record = this.records.get(id);
+    if (record === void 0) return err(missing("release", id));
+    if (record.released) {
+      return err(
+        new InstanceCollectionError(
+          "instance-collection-released",
+          `instance collection ${Number(id)} has not already been released`,
+          "do not reuse a released collection id; create a new collection",
+          {
+            operation: "release",
+            expected: "a live instance collection id",
+            actual: Number(id),
+            collectionId: id
+          }
+        )
+      );
+    }
+    record.released = true;
+    this.records.delete(id);
+    this.residency.delete(id);
+    this.epochValue += 1;
+    return ok(void 0);
+  }
+  /** Drop all canonical matrices during Renderer disposal. */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const record of this.records.values()) record.released = true;
+    this.records.clear();
+    this.residency.clear();
+    this.epochValue += 1;
+  }
+  live(operation, id) {
+    if (!Number.isInteger(id) || id <= 0) {
+      return err(invalid(operation, "collectionId is a positive integer", id, id));
+    }
+    if (this.disposed) {
+      return err(
+        new InstanceCollectionError(
+          "instance-collection-released",
+          "the Renderer-owned instance collection store is live",
+          "create a new Renderer before using instance collections",
+          { operation, expected: "a live collection store", actual: "disposed", collectionId: id }
+        )
+      );
+    }
+    const record = this.records.get(id);
+    return record === void 0 ? err(missing(operation, id)) : ok(record);
+  }
+  info(record) {
+    return Object.freeze({
+      collectionId: record.id,
+      count: record.count,
+      capacity: record.capacity,
+      revision: record.revision
+    });
+  }
+  projectInspection(record) {
+    const residency = this.residency.get(record.id);
+    return Object.freeze({
+      ...this.info(record),
+      residentGeneration: residency?.residentGeneration,
+      lane: residency?.lane ?? "unresident",
+      dirtyRanges: Object.freeze(record.dirtyRanges.map((range) => ({ ...range }))),
+      uploadRanges: Object.freeze(residency?.uploadRanges.map((range) => ({ ...range })) ?? []),
+      uploadedBytes: residency?.uploadedBytes ?? 0,
+      requestedBytes: residency?.requestedBytes ?? record.count * MATRIX_STRIDE * 4,
+      supportedBytes: residency?.supportedBytes,
+      backend: residency?.backend ?? "unknown",
+      owner: "renderer.instances",
+      error: residency?.error
+    });
+  }
+};
+
+// src/scene/visibility/budget.ts
+var DEFAULT_CONFIGURED_QUERY_BUDGET = 2048;
+var MAX_QUERY_BUDGET = 4096;
+var VISIBILITY_CANDIDATE_COUNT = 1e5;
+var VISIBILITY_OCCLUDED_COUNT = 9e4;
+function createVisibilityBudget(configuredQueryBudget = DEFAULT_CONFIGURED_QUERY_BUDGET) {
+  if (!Number.isSafeInteger(configuredQueryBudget) || configuredQueryBudget <= 0) {
+    throw new RangeError("configuredQueryBudget must be a positive safe integer");
+  }
+  const effectiveQueryBudget = Math.min(configuredQueryBudget, MAX_QUERY_BUDGET);
+  const oneSweepCandidates = oneSweep(VISIBILITY_CANDIDATE_COUNT, effectiveQueryBudget);
+  const oneSweepOccluded = oneSweep(VISIBILITY_OCCLUDED_COUNT, effectiveQueryBudget);
+  const retestSubmits = Math.max(6, oneSweepOccluded);
+  return Object.freeze({
+    configuredQueryBudget,
+    effectiveQueryBudget,
+    oneSweepCandidates,
+    oneSweepOccluded,
+    settleSubmits: 2 * oneSweepCandidates,
+    retestSubmits,
+    expirySubmits: Math.max(8, retestSubmits + oneSweepOccluded)
+  });
+}
+function oneSweep(candidateCount, effectiveQueryBudget) {
+  return Math.ceil(candidateCount / effectiveQueryBudget);
+}
+
 // src/render-contract.ts
 var STANDARD_OUTPUT_TRANSFORM_FEATURE_ID = "forgeax::standard::output-transform";
 var FXAA_POST_PROCESS_ID = "forgeax::post::fxaa";
@@ -960,6 +1565,11 @@ var RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
   "record/graph-execute/bloom-blur-h",
   "record/graph-execute/bloom-blur-v",
   "record/graph-execute/bloom-composite",
+  "record/graph-execute/ssr-hiz",
+  "record/graph-execute/ssr-trace",
+  "record/graph-execute/ssr-temporal",
+  "record/graph-execute/ssr-reflection-mip",
+  "record/graph-execute/ssr-compose",
   "record/graph-execute/other"
 ];
 var RENDER_HDRP_BINNER_PHASE_CATALOG = [
@@ -1012,6 +1622,6 @@ var RENDER_PHASE_CATALOG = [
   ...RENDER_RECORD_PHASE_CATALOG
 ];
 
-export { AtmosphereInvalidParameterError, EnvironmentGenerationFailedError, EnvironmentSourceConflictError, EquirectProjectionFailedError, FXAA_POST_PROCESS_ID, FogCardinalityError, FrameReceiptStaleError, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_COPY_SRC, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_TEXTURE_BINDING, LifecycleConstructionError, MaterialSkinAttrMissingError, ObservationUnavailableError, OwnerStageFailedError, PointShadowAtlasBoundsViolationError, PointShadowAtlasUninitializedError, PointsLinesBudgetExceededError, PointsLinesInvalidStyleError, PointsLinesMaterialUnsupportedError, PointsLinesPrepareFailedError, PointsLinesStyleUnsupportedError, PointsLinesTopologyMismatchError, RENDER_PHASE_CATALOG, RenderFeatureCapabilityMissingError, RenderFeatureDrawRecordingFailedError, RenderFeaturePreparationFailedError, RenderFeaturePreparedStateMismatchError, RenderFeatureRegistrationConflictError, RenderFeatureStageFailedError, RenderIntentInvalidError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, RenderTargetOperationFailedError, RenderTargetStateInvalidError, RendererContractFailureError, RendererOperationError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, SceneDataUnavailableError, ShadowAtlas, ShadowInvalidConfigError, SkinMaterialMismatchError, SkinPaletteOverflowError, StandardClusterIndexOverflowError, StandardClusterTransportUnavailableError, StandardLightBudgetExceededError, StandardProfileInvalidError, TaaCapsInsufficientError, TemporalFrameSubmitError, TransmissionCapabilityMissingError, VertexColorVariantConflictError, VideoUploadUnsupportedError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, VolumeOwnerConflictError, createLightResourceUnavailable };
-//# sourceMappingURL=chunk-J6KACNOH.mjs.map
-//# sourceMappingURL=chunk-J6KACNOH.mjs.map
+export { AtmosphereInvalidParameterError, AutoExposureCapabilityUnavailableError, AutoExposureInvalidParameterError, AutoExposureStageFailedError, AutoExposureStaleGenerationError, DynamicResolutionInvalidParameterError, DynamicResolutionRequiresTaaError, DynamicResolutionTimingUnavailableError, EnvironmentGenerationFailedError, EnvironmentSourceConflictError, EquirectProjectionFailedError, FXAA_POST_PROCESS_ID, FogCardinalityError, FrameReceiptStaleError, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_COPY_SRC, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_STORAGE_BINDING, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GpuDrivenPreparationError, InstanceCollectionError, InstanceCollectionStore, LifecycleConstructionError, MaterialSkinAttrMissingError, ObservationUnavailableError, OwnerStageFailedError, PointShadowAtlasBoundsViolationError, PointShadowAtlasUninitializedError, PointsLinesBudgetExceededError, PointsLinesInvalidStyleError, PointsLinesMaterialUnsupportedError, PointsLinesPrepareFailedError, PointsLinesStyleUnsupportedError, PointsLinesTopologyMismatchError, RENDER_PHASE_CATALOG, RenderFeatureCapabilityMissingError, RenderFeatureDrawRecordingFailedError, RenderFeaturePreparationFailedError, RenderFeaturePreparedStateMismatchError, RenderFeatureRegistrationConflictError, RenderFeatureStageFailedError, RenderIntentInvalidError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, RenderTargetOperationFailedError, RenderTargetStateInvalidError, RendererContractFailureError, RendererOperationError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, SceneDataUnavailableError, ShadowAtlas, ShadowInvalidConfigError, SkinMaterialMismatchError, SkinPaletteOverflowError, StandardClusterIndexOverflowError, StandardClusterTransportUnavailableError, StandardLightBudgetExceededError, StandardProfileInvalidError, TaaCapsInsufficientError, TemporalFrameSubmitError, TransmissionCapabilityMissingError, VertexColorVariantConflictError, VideoUploadUnsupportedError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, VolumeOwnerConflictError, createAutoExposureError, createAutoExposureInspection, createLightResourceUnavailable, createVisibilityBudget, instanceUploadRangesForResident };
+//# sourceMappingURL=chunk-JRBDO2KB.mjs.map
+//# sourceMappingURL=chunk-JRBDO2KB.mjs.map