@forgeax/engine-render 0.1.32 → 0.1.34

package/dist/{chunk-6TFBXLRJ.mjs → chunk-WEX45HKH.mjs}

@@ -1,5 +1,6 @@
-import { cubeArrayDepthDescriptor, comparisonSamplerDescriptor, cubeArrayDepthFaceView } from '@forgeax/engine-rhi';
 import { err, ok } from '@forgeax/engine-types';
+import { cubeArrayDepthDescriptor, comparisonSamplerDescriptor, cubeArrayDepthFaceView } from '@forgeax/engine-rhi';
+import { InstanceTransformsStrideMismatchError } from '@forgeax/engine-ecs/projection';
 
 // src/pipeline/standard-output/auto-exposure/inspection.ts
 var AutoExposureInvalidParameterError = class extends Error {
@@ -373,16 +374,16 @@ var MaterialSkinAttrMissingError = class extends Error {
   expected;
   hint;
   detail;
-  constructor(entity, missing2) {
+  constructor(entity, missing) {
     const expected = "pbr-skin material requires mesh.attributes.skinIndex + skinWeight";
-    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`;
+    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`;
     super(
-      `material/skin attribute mismatch on entity ${entity}: pbr-skin material with mesh missing ${missing2}`
+      `material/skin attribute mismatch on entity ${entity}: pbr-skin material with mesh missing ${missing}`
     );
     this.name = "MaterialSkinAttrMissingError";
     this.expected = expected;
     this.hint = hint;
-    this.detail = { entity, missing: missing2 };
+    this.detail = { entity, missing };
   }
 };
 var TransmissionCapabilityMissingError = class extends Error {
@@ -421,14 +422,20 @@ var RenderFeatureStageFailedError = class extends Error {
   expected;
   hint;
   detail;
-  constructor(featureIdentity, order, stage, recovery) {
+  constructor(featureIdentity, order, stage, recovery, cause) {
     const expected = `feature '${featureIdentity}' completes its ${stage} stage without an error`;
     const hint = renderFeatureRecoveryHintByRecovery[recovery](featureIdentity, stage);
     super(`render feature '${featureIdentity}' failed during ${stage}`);
     this.name = "RenderFeatureStageFailedError";
     this.expected = expected;
     this.hint = hint;
-    this.detail = { featureIdentity, order, stage, recovery };
+    this.detail = {
+      featureIdentity,
+      order,
+      stage,
+      recovery,
+      ...cause === void 0 ? {} : { cause }
+    };
   }
 };
 var RenderFeatureCapabilityMissingError = class extends Error {
@@ -661,6 +668,19 @@ var DynamicResolutionTimingUnavailableError = class extends Error {
     this.detail = detail;
   }
 };
+var BarrelDistortionInvalidParameterError = class extends Error {
+  code = "barrel-distortion-invalid-parameter";
+  expected;
+  hint;
+  detail;
+  constructor(detail) {
+    super(`BarrelDistortion.${detail.field} is invalid`);
+    this.name = "BarrelDistortionInvalidParameterError";
+    this.expected = `BarrelDistortion.${detail.field} must be ${detail.expected}`;
+    this.hint = `set BarrelDistortion.${detail.field} to a value that is ${detail.expected}`;
+    this.detail = detail;
+  }
+};
 var OwnerStageFailedError = class extends Error {
   code = "owner-stage-failed";
   expected = "the owner completes its current frame stage";
@@ -878,8 +898,8 @@ var RenderIntentInvalidError = class extends Error {
 };
 var VolumeOwnerConflictError = class extends Error {
   code = "volume-owner-conflict";
-  expected = "exactly one global VolumetricFog owner is authored";
-  hint = "remove additional VolumetricFog owners and retry extraction";
+  expected = "at most eight local VolumetricFog owners per rendered World";
+  hint = "reduce simultaneously visible volume owners and retry extraction";
   detail;
   constructor(ownerCount) {
     super(`volume-owner-conflict: received ${ownerCount} owners`);
@@ -912,16 +932,100 @@ var VolumeInvalidBoundsError = class extends Error {
 var VolumeInvalidParametersError = class extends Error {
   code = "volume-invalid-parameters";
   expected = "volume parameters remain finite and inside their closed ranges";
-  hint = "repair extinction, albedo, emission, anisotropy, or maxDistance";
+  hint = "repair extinction, albedo, emission, anisotropy, maxDistance, or sampling";
   detail;
   constructor(input) {
-    const field = input.maxDistance !== void 0 && input.maxDistance <= 0 ? "maxDistance" : "parameters";
-    const value = field === "maxDistance" ? input.maxDistance : input.anisotropy;
+    const invalidSampling = input.sampling !== void 0 && input.sampling !== "noise" && input.sampling !== "density";
+    const field = invalidSampling ? "sampling" : input.maxDistance !== void 0 && input.maxDistance <= 0 ? "maxDistance" : "parameters";
+    const value = invalidSampling ? input.sampling : field === "maxDistance" ? input.maxDistance : input.anisotropy;
     super(`volume-invalid-parameters: ${field} is outside the authored range`);
     this.name = "VolumeInvalidParametersError";
     this.detail = { field, value };
   }
 };
+var MOTION_BLUR_PARAMS_BYTE_SIZE = 32;
+var DEFAULT_MOTION_BLUR_PARAMS = Object.freeze({
+  shutterAngle: 180,
+  maxRadiusPixels: 32,
+  sampleCount: 8,
+  targetFps: 60
+});
+var MotionBlurValidationError = class extends Error {
+  code = "motion-blur-invalid-params";
+  expected;
+  hint;
+  detail;
+  constructor(detail) {
+    const integer = detail.integer === true ? "integer " : "";
+    const expected = `${detail.field} ${integer}in [${detail.min}, ${detail.max}]`;
+    super(`motion-blur-invalid-params: ${expected}`);
+    this.name = "MotionBlurValidationError";
+    this.expected = expected;
+    this.hint = `set ${detail.field} to an ${integer}value in [${detail.min}, ${detail.max}]`;
+    this.detail = detail;
+  }
+};
+function validateField(field, value, min, max, integer = false) {
+  if (!Number.isFinite(value) || value < min || value > max || integer && !Number.isInteger(value)) {
+    return new MotionBlurValidationError({
+      field,
+      value,
+      min,
+      max,
+      ...integer ? { integer } : {}
+    });
+  }
+  return void 0;
+}
+function validateMotionBlurParams(input) {
+  const value = input ?? {};
+  const shutterAngle = value.shutterAngle ?? DEFAULT_MOTION_BLUR_PARAMS.shutterAngle;
+  const maxRadiusPixels = value.maxRadiusPixels ?? DEFAULT_MOTION_BLUR_PARAMS.maxRadiusPixels;
+  const sampleCount = value.sampleCount ?? DEFAULT_MOTION_BLUR_PARAMS.sampleCount;
+  const targetFps = value.targetFps ?? DEFAULT_MOTION_BLUR_PARAMS.targetFps;
+  const shutterError = validateField("shutterAngle", shutterAngle, 0, 360);
+  if (shutterError !== void 0) return err(shutterError);
+  const radiusError = validateField("maxRadiusPixels", maxRadiusPixels, 0, 64);
+  if (radiusError !== void 0) return err(radiusError);
+  const sampleError = validateField("sampleCount", sampleCount, 4, 16, true);
+  if (sampleError !== void 0) return err(sampleError);
+  const targetFpsError = validateField("targetFps", targetFps, 0, 240, true);
+  if (targetFpsError !== void 0) return err(targetFpsError);
+  return ok(Object.freeze({ shutterAngle, maxRadiusPixels, sampleCount, targetFps }));
+}
+function motionBlurTemporalDemand(params) {
+  return params !== void 0 && params.shutterAngle > 0 && params.maxRadiusPixels > 0;
+}
+function effectiveMotionBlurSampleCount(sampleCount) {
+  if (!Number.isFinite(sampleCount) || sampleCount < 4) return 0;
+  if (sampleCount < 8) return 4;
+  if (sampleCount < 16) return 8;
+  return 16;
+}
+function isMotionBlurIntervalValid(frameDeltaSeconds) {
+  return Number.isFinite(frameDeltaSeconds) && frameDeltaSeconds > 0 && frameDeltaSeconds <= 0.1;
+}
+function motionBlurExposureScale(frameDeltaSeconds, targetFps) {
+  if (!isMotionBlurIntervalValid(frameDeltaSeconds)) return 0;
+  if (!Number.isFinite(targetFps) || targetFps < 0 || targetFps > 240 || !Number.isInteger(targetFps)) {
+    return 0;
+  }
+  if (targetFps === 0) return 1;
+  return 1 / (targetFps * frameDeltaSeconds);
+}
+function motionBlurSampleDelta(sampleTimeSeconds, previousSampleTimeSeconds, fallbackDeltaSeconds) {
+  if (sampleTimeSeconds !== void 0 && !Number.isFinite(sampleTimeSeconds) || previousSampleTimeSeconds !== void 0 && !Number.isFinite(previousSampleTimeSeconds)) {
+    return Number.NaN;
+  }
+  if (Number.isFinite(sampleTimeSeconds) && Number.isFinite(previousSampleTimeSeconds)) {
+    return sampleTimeSeconds - previousSampleTimeSeconds;
+  }
+  return fallbackDeltaSeconds;
+}
+function resolveMotionBlurParams(input) {
+  if (input === void 0) return ok(void 0);
+  return validateMotionBlurParams(input);
+}
 
 // src/gpu-texture-usage.ts
 var GPU_TEXTURE_USAGE_COPY_SRC = 1;
@@ -1151,251 +1255,115 @@ var GpuDrivenPreparationError = class extends Error {
   }
 };
 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;
+var InstanceTransformsError = class extends Error {
+  constructor(detail) {
+    super("Instances.transforms must contain complete finite matrices");
     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;
+    this.name = "InstanceTransformsError";
   }
-};
-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"
+  detail;
+  code = "instance-transforms-invalid";
+  expected = "finite column-major mat4 values, with transforms.length a multiple of 16";
+  hint = "repair Instances.transforms in the World or source SceneAsset and retry";
+};
+function validateInstanceTransforms(transforms) {
+  if (transforms.length % MATRIX_STRIDE !== 0)
+    return new InstanceTransformsStrideMismatchError(transforms.length);
+  for (let index = 0; index < transforms.length; index++) {
+    if (!Number.isFinite(transforms[index]))
+      return new InstanceTransformsError({
+        actualLength: transforms.length,
+        nonFiniteIndex: index
       });
-    }
   }
   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 }
-  );
+function instanceUploadRangesForResident(activeIsNew, dirtyRanges, fullRange) {
+  return activeIsNew ? [fullRange] : dirtyRanges;
 }
-var InstanceCollectionStore = class {
+var InstanceProjectionStore = class {
   nextId = 1;
-  epochValue = 0;
-  disposed = false;
+  nextGeneration = 1;
+  identities = /* @__PURE__ */ new WeakMap();
   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;
+  project(world, entity, transforms) {
+    const collectionId = this.identities.get(world)?.get(entity) ?? this.nextId++;
+    const previous = this.records.get(collectionId);
+    if (previous !== void 0 && previous.transforms.length === transforms.length && previous.transforms.every((value, index) => Object.is(value, transforms[index])))
+      return previous;
+    const count = transforms.length / MATRIX_STRIDE;
+    const generations = previous?.count === count ? previous.generations : Uint32Array.from({ length: count }, () => this.nextGeneration++);
     const record = {
-      id,
-      transforms: new Float32Array(input.transforms),
+      collectionId,
+      world,
+      entity,
+      transforms: new Float32Array(transforms),
+      generations,
       count,
-      capacity: nextCapacity(Math.max(INITIAL_CAPACITY, count)),
-      revision: 1,
-      dirtyRanges: count === 0 ? [] : [{ start: 0, end: count }],
-      lastSnapshotRevision: 0,
-      released: false
+      revision: (previous?.revision ?? 0) + 1
     };
-    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"
-          }
-        )
-      );
+    return record;
+  }
+  /** Called only after the owning RenderScene accepts its prepared changes. */
+  accept(world, entity, snapshot) {
+    const { collectionId, revision, transforms, generations } = snapshot;
+    if (collectionId === void 0 || revision === void 0 || generations === void 0) return;
+    let entities = this.identities.get(world);
+    if (entities === void 0) {
+      entities = /* @__PURE__ */ new Map();
+      this.identities.set(world, entities);
     }
-    if (record.value.lastSnapshotRevision === record.value.revision) {
-      record.value.dirtyRanges = [];
+    entities.set(entity, collectionId);
+    this.records.set(collectionId, {
+      collectionId,
+      revision,
+      transforms,
+      generations,
+      count: transforms.length / MATRIX_STRIDE,
+      world,
+      entity
+    });
+  }
+  release(world, entity) {
+    const entities = this.identities.get(world);
+    const id = entities?.get(entity);
+    if (id === void 0) return;
+    entities?.delete(entity);
+    this.records.delete(id);
+    this.residency.delete(id);
+  }
+  retain(ids) {
+    for (const record of this.records.values()) {
+      if (!ids.has(record.collectionId)) this.release(record.world, record.entity);
     }
-    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;
+  dispose() {
+    this.records.clear();
+    this.residency.clear();
+    this.identities = /* @__PURE__ */ new WeakMap();
   }
-  /**
-   * 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))
-    );
+  _resetResidency() {
+    this.residency.clear();
   }
-  /** @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 }));
+    const sameFrame = previous?.frameNumber === input.frameNumber && previous.error === void 0;
+    const ranges = [...sameFrame ? previous.uploadRanges : [], ...input.uploadRanges].map((range) => ({ ...range })).sort((a, b) => a.start - b.start);
+    const uploadRanges = [];
+    for (const range of ranges) {
+      const last = uploadRanges.at(-1);
+      if (last !== void 0 && range.start <= last.end) last.end = Math.max(last.end, range.end);
+      else uploadRanges.push(range);
+    }
     this.residency.set(input.collectionId, {
-      frameNumber: input.frameNumber,
-      residentGeneration: input.residentGeneration,
-      lane: input.lane,
+      ...input,
       uploadRanges,
-      uploadedBytes: sameFrame ? previous.uploadedBytes + input.uploadedBytes : input.uploadedBytes,
-      requestedBytes: input.requestedBytes,
-      supportedBytes: input.supportedBytes,
-      backend: input.backend,
+      uploadedBytes: input.uploadedBytes + (sameFrame ? previous.uploadedBytes : 0),
       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, {
@@ -1415,106 +1383,24 @@ var InstanceCollectionStore = class {
       }
     });
   }
-  /** @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.detachedSnapshot(value);
-    return ok(result);
-  }
-  /**
-   * Read a detached matrix view without advancing the render-consumption
-   * cursor. Inspection and picking may call this between authoring updates;
-   * the next renderer snapshot must still receive the complete dirty union.
-   */
-  peek(id) {
-    const record = this.live("inspect", id);
-    return record.ok ? ok(this.detachedSnapshot(record.value)) : record;
-  }
-  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);
-  }
-  detachedSnapshot(record) {
-    return {
-      ...this.info(record),
-      transforms: new Float32Array(record.transforms),
-      dirtyRanges: record.dirtyRanges.map((range) => ({ ...range }))
-    };
-  }
-  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
+  _inspections(frameNumber) {
+    return [...this.records.values()].map((record) => {
+      const resident = this.residency.get(record.collectionId);
+      const current = resident?.frameNumber === frameNumber;
+      return {
+        collectionId: record.collectionId,
+        count: record.count,
+        revision: record.revision,
+        residentGeneration: resident?.residentGeneration,
+        lane: resident?.lane ?? "unresident",
+        uploadRanges: current ? resident.uploadRanges.map((range) => ({ ...range })) : [],
+        uploadedBytes: current ? resident.uploadedBytes : 0,
+        requestedBytes: resident?.requestedBytes ?? record.transforms.byteLength,
+        supportedBytes: resident?.supportedBytes,
+        backend: resident?.backend ?? "unknown",
+        owner: "renderer.instances",
+        error: resident?.error
+      };
     });
   }
 };
@@ -1573,9 +1459,8 @@ var RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
   "record/graph-execute/skybox",
   "record/graph-execute/main",
   "record/graph-execute/fxaa",
-  "record/graph-execute/bloom-bright",
-  "record/graph-execute/bloom-blur-h",
-  "record/graph-execute/bloom-blur-v",
+  "record/graph-execute/bloom-downsample",
+  "record/graph-execute/bloom-upsample",
   "record/graph-execute/bloom-composite",
   "record/graph-execute/ssr-hiz",
   "record/graph-execute/ssr-trace",
@@ -1634,6 +1519,6 @@ var RENDER_PHASE_CATALOG = [
   ...RENDER_RECORD_PHASE_CATALOG
 ];
 
-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-6TFBXLRJ.mjs.map
-//# sourceMappingURL=chunk-6TFBXLRJ.mjs.map
+export { AtmosphereInvalidParameterError, AutoExposureCapabilityUnavailableError, AutoExposureInvalidParameterError, AutoExposureStageFailedError, AutoExposureStaleGenerationError, BarrelDistortionInvalidParameterError, DEFAULT_MOTION_BLUR_PARAMS, 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, InstanceProjectionStore, InstanceTransformsError, LifecycleConstructionError, MOTION_BLUR_PARAMS_BYTE_SIZE, MaterialSkinAttrMissingError, MotionBlurValidationError, 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, effectiveMotionBlurSampleCount, instanceUploadRangesForResident, isMotionBlurIntervalValid, motionBlurExposureScale, motionBlurSampleDelta, motionBlurTemporalDemand, resolveMotionBlurParams, validateInstanceTransforms, validateMotionBlurParams };
+//# sourceMappingURL=chunk-WEX45HKH.mjs.map
+//# sourceMappingURL=chunk-WEX45HKH.mjs.map