@forgeax/engine-render 0.1.21 → 0.1.23

package/src/render-system.ts

@@ -19,19 +19,10 @@
 import { numMipLevels, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
+import { mat4 } from '@forgeax/engine-math';
 import type { RecorderSession } from '@forgeax/engine-profiler';
 import type { CompiledRenderGraphInfo } from '@forgeax/engine-render-graph';
-import type {
-  BindGroup,
-  BindGroupEntry,
-  BindGroupLayout,
-  Buffer,
-  RenderPipeline,
-  Sampler,
-  Texture,
-  TextureFormat,
-  TextureView,
-} from '@forgeax/engine-rhi';
+import type { BindGroupEntry, BindGroupLayout, Buffer, RenderPipeline } from '@forgeax/engine-rhi';
 import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
 import {
   derive,
@@ -82,10 +73,14 @@ import { GpuDrivenProduction } from './gpu-driven/production-raster';
 import type {
   BloomInspection,
   DirectionalShadowInspection,
+  GpuDrivenProductionInspection,
+  LodOcclusionInspection,
+  LodOcclusionInspectionRow,
+  LodOcclusionWorldInspection,
   MotionBlurInspection,
   ReflectionProbeInspection,
-  ReflectionProbeSelectionInspection,
   RenderSceneInspection,
+  SsrDependenciesInspection,
   TemporalTargetInspection,
   TransmissionInspection,
 } from './inspection-types';
@@ -103,25 +98,19 @@ import {
 import { createPointsLinesLaneAdapter, type PointsLinesBackend } from './points-lines/record';
 import type { PointsLinesRetainedSnapshot } from './points-lines/snapshot';
 import type { PointsLinesRecordOwner, PointsLinesRecordSubmission } from './record/render-context';
+import { ReflectionProbeRecordOwner } from './reflection/record-owner';
+import {
+  OcclusionRenderRuntime,
+  type OcclusionRuntimeCandidate,
+} from './scene/visibility/occlusion-runtime';
+import { primitiveKey, viewKey } from './scene/visibility/types';
 import { inspectVolumetricFog } from './volume/inspection';
 
 export type { RenderSceneInspection } from './inspection-types';
 
 import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
-import { mat4, vec3 } from '@forgeax/engine-math';
-import { buildCubeCameraFaceViews } from './capture/cube-views';
 import { createCubeCaptureScheduler } from './capture/scheduler';
-import {
-  createFaceUniformsBuffer,
-  createPrefilterUniformsBuffer,
-  writeAllFaceUniforms,
-  writeAllPrefilterUniforms,
-} from './device/gpu-residency';
 import type { EnvironmentInspection } from './environment/inspection';
-import {
-  GPU_TEXTURE_USAGE_COPY_SRC,
-  GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING,
-} from './gpu-texture-usage';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_INDEX,
@@ -129,13 +118,6 @@ import {
   GPU_BUFFER_USAGE_VERTEX,
 } from './gpu-usage';
 import { resetHdrpBuffers } from './hdrp-buffers';
-import {
-  CUBEMAP_FACE_VERTICES,
-  createIblPipelines,
-  getOrCreateIblCache,
-  PREFILTER_MIP_LEVELS,
-  PREFILTER_SIZE,
-} from './ibl/IblPipelineCache';
 import { assembleMaterialWithSkylightEntries } from './ibl/skylight-bind-group';
 import { disposeInstanceBuffers, disposeTransientInstanceBuffers } from './instance-buffer-cache';
 import {
@@ -168,7 +150,7 @@ import type {
   GraphTargetCaptureRequest,
   RenderFrameState,
 } from './record/frame-snapshot';
-import { getTextureIdentity } from './record/frame-snapshot';
+import { getTextureIdentity, worldEntityKey } from './record/frame-snapshot';
 import type { GpuPassTimingReason } from './record/gpu-pass-timing/errors';
 import type {
   GpuPassTimingCapture,
@@ -176,28 +158,15 @@ import type {
   GpuPassTimingSession,
 } from './record/gpu-pass-timing/session';
 import type { GpuTimingCapture } from './record/gpu-timing';
+import { computeProjectionMatrix, computeViewMatrix } from './record/helpers';
 import { applyParamSnapshotToUbo, residentTextureView } from './record/main-pass-material';
-import type { ReflectionProbeRecordState, RenderSystemInternals } from './record/render-context';
-import type { CubeCaptureGraphState, ReflectionProbeGraphWork } from './record/typed-frame-graph';
+import type { RenderSystemInternals } from './record/render-context';
+import type { CubeCaptureGraphState } from './record/typed-frame-graph';
 import {
   type RenderFeatureGraphCandidate,
   resetRenderFeatureGraphState,
   settleVolumetricFogGraphCandidate,
 } from './record/typed-frame-graph';
-import { REFLECTION_PROBE_VIEW_SLOT_BASE, VIEW_UNIFORM_SLOT_STRIDE } from './record/view-ubo';
-import {
-  advanceProbeFilter,
-  commitProbeFilterStep,
-  createProbeFilterState,
-  type ProbeFilterState,
-} from './reflection/filter';
-import { buildReflectionProbeTable } from './reflection/gpu-table';
-import {
-  admitReflectionProbe,
-  DEFAULT_REFLECTION_PROBE_LIMITS,
-  type ReflectionProbeFact,
-  type ReflectionProbeSelectionResult,
-} from './reflection/projection';
 import {
   type CameraSnapshot,
   type DrawOwnerOptions,
@@ -215,7 +184,9 @@ import type {
 } from './render-system-extract';
 import { extractFrames } from './render-system-extract';
 import { PersistentRenderScene } from './scene/render-scene';
+import { inspectLodOcclusion } from './scene/visibility/inspection';
 import { resolveSsaoParameters } from './ssao-config';
+import { projectSsrDependencies, resolveSsrAdmissionGeneration } from './ssr/admission';
 import {
   getTransparentSortConfig,
   TRANSPARENT_SORT_MODE_DISTANCE,
@@ -239,6 +210,121 @@ import {
   inspectTransmissionFromAdmission,
 } from './transmission/inspection';
 
+interface LodInspectionQuerySummary {
+  readonly used: number;
+  readonly capacity: number;
+}
+
+function createLodWorldInspections(
+  worlds: readonly World[],
+  renderables: readonly RenderableSnapshot[],
+  submittedRenderables: readonly RenderableSnapshot[],
+  camera: CameraSnapshot,
+  frameId: number,
+  worldKeys: readonly number[],
+  slots: ReadonlyMap<number, { readonly slot: number; readonly generation: number }>,
+  query: LodInspectionQuerySummary,
+  fallback: LodOcclusionInspection['fallback'],
+  degradation: LodOcclusionInspection['degradation'],
+): readonly LodOcclusionWorldInspection[] {
+  // The CPU projection knows which renderables belong to each World, but it
+  // does not receive the GPU selector/query counters split by World from the
+  // same submit. Keep these rows available for diagnostics while explicitly
+  // marking their attribution unavailable; producers must not promote them
+  // to World-reorder evidence by inferring facts from array order.
+  const attribution = Object.freeze({
+    status: 'unavailable' as const,
+    reason: 'projection-only' as const,
+  });
+  const submitted = new Set(submittedRenderables);
+  const sampleLimit = 64;
+  const accumulators = worlds.map(() => ({
+    allCount: 0,
+    allVisible: 0,
+    allSamples: [] as RenderableSnapshot[],
+    lodCount: 0,
+    lodVisible: 0,
+    lodSamples: [] as RenderableSnapshot[],
+  }));
+  // Keep this projection bounded: the old implementation filtered the full
+  // 100k renderable list twice per World on every frame and retained another
+  // Set-backed traversal just to derive the six counters below. One pass is
+  // enough because the inspection only needs counts, the first row identity,
+  // and at most 64 detached samples.
+  for (const renderable of renderables) {
+    const accumulator = accumulators[renderable.worldId];
+    if (accumulator === undefined) continue;
+    const visible = submitted.has(renderable);
+    accumulator.allCount += 1;
+    if (visible) accumulator.allVisible += 1;
+    if (accumulator.allSamples.length < sampleLimit) accumulator.allSamples.push(renderable);
+    if ((renderable.lods?.length ?? 0) > 0) {
+      accumulator.lodCount += 1;
+      if (visible) accumulator.lodVisible += 1;
+      if (accumulator.lodSamples.length < sampleLimit) accumulator.lodSamples.push(renderable);
+    }
+  }
+  const result: LodOcclusionWorldInspection[] = [];
+  for (let worldId = 0; worldId < worlds.length; worldId += 1) {
+    const world = worlds[worldId];
+    if (world === undefined) continue;
+    const accumulator = accumulators[worldId];
+    if (accumulator === undefined || accumulator.allCount === 0) {
+      result.push(
+        Object.freeze({ attachmentId: world.identity, rows: Object.freeze([]), attribution }),
+      );
+      continue;
+    }
+    const usesLod = accumulator.lodCount > 0;
+    const candidateCount = usesLod ? accumulator.lodCount : accumulator.allCount;
+    const visible = usesLod ? accumulator.lodVisible : accumulator.allVisible;
+    const samples = usesLod ? accumulator.lodSamples : accumulator.allSamples;
+    const first = samples[0];
+    const slot =
+      first === undefined
+        ? undefined
+        : slots.get(worldEntityKey(worldKeys[first.worldId] ?? first.worldId, first.entityKey));
+    const row: LodOcclusionInspectionRow = {
+      root: {
+        guid: first === undefined ? 'none' : `asset-handle:${first.assetHandle}`,
+        sourceKey: `render-world:${world.identity}`,
+      },
+      view: {
+        attachmentId: world.identity,
+        cameraEntity: world === worlds[camera.worldId ?? 0] ? (camera.entityKey ?? 0) : 0,
+        viewRole: 'main',
+        viewGeneration: camera.historyVersion ?? 0,
+      },
+      slot: { primitiveSlot: slot?.slot ?? 0, slotGeneration: slot?.generation ?? 0 },
+      generation: frameId,
+      count: { candidates: candidateCount, visible, occluded: candidateCount - visible },
+      lodHistogram: [{ level: 0, count: candidateCount }],
+      queryLatencyUs: { median: 0, p95: 0, last: 0 },
+      pagePressure: query,
+      fallback,
+      degradation,
+      samples: samples.map((candidate, index) => ({
+        primitiveSlot:
+          slots.get(
+            worldEntityKey(worldKeys[candidate.worldId] ?? candidate.worldId, candidate.entityKey),
+          )?.slot ?? index,
+        level: 0,
+        visible: submitted.has(candidate),
+      })),
+    };
+    result.push(
+      Object.freeze({
+        attachmentId: world.identity,
+        rows: Object.freeze([row]),
+        attribution,
+      }),
+    );
+  }
+  return Object.freeze(
+    result.sort((left, right) => left.attachmentId.localeCompare(right.attachmentId)),
+  );
+}
+
 type TimingSessionHost = RenderSystemInternals & {
   gpuPassTimingSession?: GpuPassTimingSession | undefined;
   gpuPassTimingCapture?: GpuPassTimingCapture | undefined;
@@ -323,7 +409,7 @@ function sortTransparentDispatch(
     const camPos = camera.position;
 
     // Squared camera distance per entry (negated → ascending = back-to-front).
-    // D-3: world position = translation column of Transform.world (m[12,13,14]).
+    // D-3: world position = translation column of GlobalTransform.world (m[12,13,14]).
     const negDistSq = (entry: DispatchEntry): number => {
       const tx = renderables[entry.renderableIndex]?.transform;
       if (tx === undefined) return 0;
@@ -429,6 +515,8 @@ export interface RenderSystem {
   observeCurrentFrame(
     options: FrameObservationOptions,
   ): Promise<Result<FrameObservation, ObservationUnavailableError>>;
+  /** Resolve the renderer-owned GPU LOD counters for the last accepted submit. */
+  observeLodOcclusion(): Promise<void>;
   /** Internal same-frame graph target access for backend diagnostics. */
   getCurrentGraphTarget(name: string): CurrentGraphTarget | undefined;
   /** Internal test capture copied into the draw's command submission. */
@@ -446,6 +534,10 @@ export interface RenderSystem {
   /** Persistent scene maintenance evidence from the ordinary single-World path. */
   readonly renderScene: RenderSceneInspection;
   readonly reflectionProbes: ReflectionProbeInspection;
+  /** Live producer/RHI/temporal receipts projected through SSR admission. */
+  readonly ssrDependencies: SsrDependenciesInspection;
+  /** Producer completion fence included in the public FrameReceipt. */
+  readonly reflectionFallbackCompletion: Promise<void> | undefined;
   /** True while a progressive CubeCamera candidate still owns unfinished faces. */
   isCubeCapturePending(target: RenderTarget): boolean;
   readonly environment: EnvironmentInspection;
@@ -453,6 +545,9 @@ export interface RenderSystem {
   readonly bloom: BloomInspection;
   readonly motionBlurInspection: MotionBlurInspection | undefined;
   readonly temporalTargetInspection: TemporalTargetInspection | undefined;
+  readonly lodOcclusionInspection: LodOcclusionInspection | undefined;
+  /** Bounded GPU-driven counters without materializing the persistent scene table. */
+  readonly gpuDrivenInspection: GpuDrivenProductionInspection;
   /** Last completed transmission candidate facts, detached from GPU handles. */
   readonly transmission: TransmissionInspection | undefined;
   /** Single production projection of Directional author/extract/record facts. */
@@ -1022,551 +1117,6 @@ class StandardPointsLinesOwner implements PointsLinesRecordOwner {
   }
 }
 
-type ProbeCubeSet = {
-  readonly texture: Texture;
-  readonly cubeView: TextureView;
-  readonly faceViews: readonly TextureView[];
-  readonly mipViews: readonly (readonly TextureView[])[];
-  readonly depthTexture: Texture;
-  readonly depthView: TextureView;
-  readonly size: number;
-};
-
-type ProbeGpuResource = {
-  fact: ReflectionProbeFact;
-  index: number;
-  filter: ProbeFilterState;
-  rawFaceCursor: number;
-  readonly raw: ProbeCubeSet;
-  active: ProbeCubeSet | undefined;
-  candidate: ProbeCubeSet;
-  spare: ProbeCubeSet | undefined;
-  readonly sampler: Sampler;
-  readonly uniformBuffer: Buffer;
-  readonly filterGroup1: BindGroup;
-  pending?: {
-    readonly rawCaptureFace: number | undefined;
-    readonly step: ReturnType<typeof advanceProbeFilter>;
-  };
-};
-
-type ProbeSharedResources = {
-  readonly faceUniforms: Buffer;
-  readonly prefilterUniforms: Buffer;
-  readonly vertexBuffer: Buffer;
-  readonly sampler: Sampler;
-  readonly filterPipeline: RenderPipeline;
-  readonly cubeGroup1Bgl: BindGroupLayout;
-  readonly prefilterGroup0Bgl: BindGroupLayout;
-};
-
-/** Renderer-owned raw capture and incremental PMREM/LKG promotion owner. */
-class ReflectionProbeRecordOwner {
-  private readonly resources = new Map<string, ProbeGpuResource>();
-  private shared: ProbeSharedResources | undefined;
-  private pipelineWarmup: Promise<void> | undefined;
-  private pipelineWarmupFailure: string | undefined;
-  private pipelineWarmupAttempts = 0;
-  private lastFactCount = 0;
-  private lastAcceptedCount = 0;
-  private lastScheduledRawFaces = 0;
-  private lastScheduledFilteredSteps = 0;
-  private lastSelection: ReflectionProbeSelectionInspection = { kind: 'skylight' };
-  private readonly outputFormat: TextureFormat;
-
-  constructor(private readonly internals: RenderSystemInternals) {
-    this.outputFormat = internals.device.caps.rgba16floatRenderable ? 'rgba16float' : 'rgba8unorm';
-  }
-
-  inspect(): ReflectionProbeInspection {
-    let rawFacesCaptured = 0;
-    let filteredStepsCompleted = 0;
-    const filteredMipLevels = new Set<number>();
-    let activeCount = 0;
-    for (const resource of this.resources.values()) {
-      rawFacesCaptured += resource.rawFaceCursor;
-      filteredStepsCompleted += resource.filter.cursor;
-      const completedMipCount = Math.min(
-        PREFILTER_MIP_LEVELS,
-        Math.floor(resource.filter.cursor / resource.filter.faceCount),
-      );
-      for (let mip = 0; mip < completedMipCount; mip += 1) filteredMipLevels.add(mip);
-      if (resource.active !== undefined) activeCount += 1;
-    }
-    return {
-      selection: this.lastSelection,
-      factCount: this.lastFactCount,
-      acceptedCount: this.lastAcceptedCount,
-      activeCount,
-      rawFacesCaptured,
-      filteredStepsCompleted,
-      filteredMipLevels: [...filteredMipLevels].sort((a, b) => a - b),
-      scheduledRawFaces: this.lastScheduledRawFaces,
-      scheduledFilteredSteps: this.lastScheduledFilteredSteps,
-      pipelineReady: this.shared !== undefined,
-      pipelineWarmupAttempts: this.pipelineWarmupAttempts,
-      ...(this.pipelineWarmupFailure === undefined
-        ? {}
-        : { pipelineWarmupFailure: this.pipelineWarmupFailure }),
-    };
-  }
-
-  private ensurePipelineWarmup(): void {
-    if (this.shared !== undefined || this.pipelineWarmup !== undefined) return;
-    const factory = this.internals.shaderModuleFactory;
-    if (factory === undefined) return;
-    const attempt = this.pipelineWarmupAttempts + 1;
-    this.pipelineWarmupAttempts = attempt;
-    this.pipelineWarmup = createIblPipelines(
-      this.internals.deviceScope,
-      this.internals.device,
-      (device, descriptor) => {
-        const labeled = {
-          ...descriptor,
-          label: `${descriptor.label ?? 'ibl'}-reflection-probe-${attempt}`,
-        };
-        return this.internals.createShaderModule === undefined
-          ? Promise.resolve(factory.createShaderModule(labeled))
-          : this.internals.createShaderModule(device, labeled);
-      },
-      this.outputFormat,
-    ).then((result) => {
-      if (!result.ok) {
-        this.pipelineWarmupFailure = `${result.error.code}: ${result.error.hint}`;
-        console.warn('[forgeax] ReflectionProbe IBL warmup retry', this.pipelineWarmupFailure);
-        this.pipelineWarmup = undefined;
-        return;
-      }
-      this.shared = this.createSharedResources(result.value.prefilterPipeline);
-      if (this.shared === undefined) {
-        this.pipelineWarmupFailure = 'renderer-owned IBL resources could not be allocated';
-        console.warn('[forgeax] ReflectionProbe IBL resource allocation retry');
-        this.pipelineWarmup = undefined;
-      }
-    });
-  }
-
-  prepare(
-    facts: readonly ReflectionProbeFact[],
-    selections: ReadonlyMap<string, ReflectionProbeSelectionResult>,
-    displayCamera: CameraSnapshot | undefined,
-  ): ReflectionProbeRecordState {
-    this.lastFactCount = facts.length;
-    this.lastScheduledRawFaces = 0;
-    this.lastScheduledFilteredSteps = 0;
-    const selectedProbe = [...selections.values()]
-      .filter(
-        (selection): selection is Extract<ReflectionProbeSelectionResult, { kind: 'probe' }> =>
-          selection.kind === 'probe',
-      )
-      .sort((a, b) => a.worldId - b.worldId || a.entityKey - b.entityKey)[0];
-    this.lastSelection =
-      selectedProbe === undefined
-        ? { kind: 'skylight' }
-        : { kind: 'probe', worldId: selectedProbe.worldId, entityKey: selectedProbe.entityKey };
-    if (facts.length > 0) this.ensurePipelineWarmup();
-    void this.pipelineWarmup;
-    const ordered = facts
-      .slice()
-      .sort((a, b) => a.worldId - b.worldId || a.entityKey - b.entityKey);
-    let acceptedCount = 0;
-    let acceptedBytes = 0;
-    const accepted = new Map<string, ProbeGpuResource>();
-    for (const fact of ordered) {
-      const admission = admitReflectionProbe(
-        fact,
-        { acceptedCount, acceptedBytes },
-        DEFAULT_REFLECTION_PROBE_LIMITS,
-      );
-      if (!admission.ok) continue;
-      const key = `${fact.worldId}:${fact.entityKey}`;
-      const resource = this.resourceFor(key, fact, acceptedCount);
-      if (resource === undefined) continue;
-      acceptedCount += 1;
-      acceptedBytes = admission.acceptedBytes;
-      accepted.set(key, resource);
-    }
-    for (const [key, resource] of this.resources) {
-      if (!accepted.has(key)) {
-        this.destroyProbeResource(resource);
-        this.resources.delete(key);
-      } else resource.index = [...accepted.keys()].indexOf(key);
-    }
-    const rows = [...accepted.values()]
-      .map((resource) => {
-        const active = resource.active;
-        if (active === undefined) return undefined;
-        return {
-          primitiveKey: `${resource.fact.worldId}:${resource.fact.entityKey}`,
-          index: resource.index,
-          worldId: resource.fact.worldId,
-          entityKey: resource.fact.entityKey,
-          center: resource.fact.center,
-          halfExtents: resource.fact.halfExtents,
-          intensity: resource.fact.intensity,
-          generation: resource.filter.activeGeneration,
-          filteredView: active.cubeView,
-          sampler: resource.sampler,
-          uniformBuffer: resource.uniformBuffer,
-        };
-      })
-      .filter((row): row is NonNullable<typeof row> => row !== undefined);
-    const table = buildReflectionProbeTable(rows);
-    const work: ReflectionProbeGraphWork[] = [];
-    for (const resource of accepted.values()) {
-      const rawCaptureFace =
-        resource.rawFaceCursor < resource.raw.faceViews.length ? resource.rawFaceCursor : undefined;
-      const step =
-        resource.rawFaceCursor >= resource.raw.faceViews.length
-          ? advanceProbeFilter(resource.filter)
-          : undefined;
-      if (this.shared === undefined) continue;
-      if (rawCaptureFace === undefined && step === undefined) continue;
-      const filterGroup0 =
-        step === undefined
-          ? undefined
-          : this.internals.device.createBindGroup({
-              label: `reflection-probe-${resource.index}-pmrem-${step.mipLevel}-${step.faceIndex}`,
-              layout: this.shared.prefilterGroup0Bgl,
-              entries: [
-                {
-                  binding: 0,
-                  resource: {
-                    kind: 'buffer',
-                    value: {
-                      buffer: this.shared.faceUniforms,
-                      offset: step.faceIndex * 256,
-                      size: 64,
-                    },
-                  },
-                },
-                {
-                  binding: 1,
-                  resource: {
-                    kind: 'buffer',
-                    value: {
-                      buffer: this.shared.prefilterUniforms,
-                      offset: (step.mipLevel * 6 + step.faceIndex) * 256,
-                      size: 16,
-                    },
-                  },
-                },
-              ],
-            });
-      if (filterGroup0 !== undefined && !filterGroup0.ok) continue;
-      if (resource.pending !== undefined) continue;
-      resource.pending = { rawCaptureFace, step };
-      if (rawCaptureFace !== undefined) this.lastScheduledRawFaces += 1;
-      if (step !== undefined) this.lastScheduledFilteredSteps += 1;
-      const face =
-        rawCaptureFace === undefined
-          ? undefined
-          : buildCubeCameraFaceViews({
-              position: resource.fact.center,
-              near: 0.1,
-              far: 100,
-            })[rawCaptureFace];
-      const faceCamera =
-        face === undefined || displayCamera === undefined
-          ? undefined
-          : {
-              ...displayCamera,
-              position: vec3.create(
-                resource.fact.center[0] ?? 0,
-                resource.fact.center[1] ?? 0,
-                resource.fact.center[2] ?? 0,
-              ),
-              world: mat4.invert(mat4.create(), face.view),
-              fov: Math.PI / 2,
-              aspect: 1,
-              near: face.near,
-              far: face.far,
-              projection: 'perspective' as const,
-            };
-      work.push({
-        probeIndex: resource.index,
-        rawTexture: resource.raw.texture,
-        rawCubeView: resource.raw.cubeView,
-        rawFaceViews: resource.raw.faceViews,
-        rawDepthTexture: resource.raw.depthTexture,
-        filteredTexture: resource.candidate.texture,
-        filteredCubeView: resource.candidate.cubeView,
-        filteredFaceViewsByMip: resource.candidate.mipViews,
-        outputFormat: this.outputFormat,
-        sampler: resource.sampler,
-        filterPipeline: this.shared.filterPipeline,
-        filterGroup0: filterGroup0?.value,
-        filterGroup1: resource.filterGroup1,
-        cubeVertexBuffer: this.shared.vertexBuffer,
-        rawCaptureFace,
-        rawDepthView: resource.raw.depthView,
-        rawSize: resource.raw.size,
-        ...(faceCamera === undefined ? {} : { faceCamera }),
-        ...(rawCaptureFace === undefined
-          ? {}
-          : {
-              viewBindGroupDynamicOffset:
-                (REFLECTION_PROBE_VIEW_SLOT_BASE + resource.index) * VIEW_UNIFORM_SLOT_STRIDE,
-            }),
-        filteredSize: resource.candidate.size,
-        step,
-      });
-    }
-    return {
-      table,
-      selections,
-      graph: { work },
-      completeSubmission: (submitted, completed) => this.completeSubmission(submitted, completed),
-    };
-  }
-
-  private completeSubmission(submitted: boolean, completed?: Promise<unknown>): void {
-    if (completed !== undefined) {
-      void completed.then(
-        () => this.completeSubmission(submitted),
-        () => this.completeSubmission(false),
-      );
-      return;
-    }
-    for (const resource of this.resources.values()) {
-      const pending = resource.pending;
-      delete resource.pending;
-      if (!submitted || pending === undefined) continue;
-      if (pending.rawCaptureFace !== undefined) {
-        resource.rawFaceCursor = Math.min(
-          resource.rawFaceCursor + 1,
-          resource.raw.faceViews.length,
-        );
-        continue;
-      }
-      if (pending.step === undefined) continue;
-      resource.filter = commitProbeFilterStep(resource.filter, true);
-      if (resource.filter.cursor >= resource.filter.faceCount * resource.filter.mipCount) {
-        const previous = resource.active;
-        resource.active = resource.candidate;
-        resource.candidate = resource.spare ?? previous ?? resource.candidate;
-        resource.spare = undefined;
-      }
-    }
-  }
-
-  dispose(): void {
-    for (const resource of this.resources.values()) {
-      this.destroyProbeResource(resource);
-    }
-    this.resources.clear();
-    if (this.shared !== undefined) {
-      this.internals.device.destroyBuffer(this.shared.faceUniforms);
-      this.internals.device.destroyBuffer(this.shared.prefilterUniforms);
-      this.internals.device.destroyBuffer(this.shared.vertexBuffer);
-    }
-    this.shared = undefined;
-    this.pipelineWarmup = undefined;
-  }
-
-  private destroyProbeResource(resource: ProbeGpuResource): void {
-    const sets = new Set<ProbeCubeSet>([resource.raw, resource.candidate]);
-    if (resource.active !== undefined) sets.add(resource.active);
-    if (resource.spare !== undefined) sets.add(resource.spare);
-    for (const set of sets) this.destroyCubeSet(set);
-    this.internals.device.destroyBuffer(resource.uniformBuffer);
-  }
-
-  private destroyCubeSet(set: ProbeCubeSet): void {
-    this.internals.device.destroyTexture(set.texture);
-    this.internals.device.destroyTexture(set.depthTexture);
-  }
-
-  private resourceFor(
-    key: string,
-    fact: ReflectionProbeFact,
-    index: number,
-  ): ProbeGpuResource | undefined {
-    const existing = this.resources.get(key);
-    if (existing !== undefined) {
-      if (existing.fact.revision !== fact.revision) {
-        existing.fact = fact;
-        existing.filter = createProbeFilterState({
-          probeIndex: index,
-          mipCount: PREFILTER_MIP_LEVELS,
-          activeGeneration: existing.filter.activeGeneration,
-        });
-        existing.rawFaceCursor = 0;
-      } else {
-        existing.fact = fact;
-        existing.index = index;
-      }
-      return existing;
-    }
-    if (this.shared === undefined) return undefined;
-    const raw = this.createCubeSet(`reflection-probe-${index}-raw`, fact.resolution);
-    const candidate = this.createCubeSet(`reflection-probe-${index}-candidate`, fact.resolution);
-    const spare = this.createCubeSet(`reflection-probe-${index}-spare`, fact.resolution);
-    if (raw === undefined || candidate === undefined || spare === undefined) return undefined;
-    const uniformBuffer = this.internals.device.createBuffer({
-      label: `reflection-probe-${index}-uniforms`,
-      size: 32,
-      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-      mappedAtCreation: false,
-    });
-    if (!uniformBuffer.ok) return undefined;
-    const payload = new Float32Array([
-      -Math.max(0, fact.intensity),
-      fact.center[0],
-      fact.center[1],
-      fact.center[2],
-      fact.halfExtents[0],
-      fact.halfExtents[1],
-      fact.halfExtents[2],
-      0,
-    ]);
-    const written = this.internals.device.queue.writeBuffer(uniformBuffer.value, 0, payload);
-    if (!written.ok) return undefined;
-    const filterGroup1 = this.internals.device.createBindGroup({
-      label: `reflection-probe-${index}-filter-input`,
-      layout: this.shared.cubeGroup1Bgl,
-      entries: [
-        { binding: 0, resource: { kind: 'textureView', value: raw.cubeView } },
-        { binding: 1, resource: { kind: 'sampler', value: this.shared.sampler } },
-      ],
-    });
-    if (!filterGroup1.ok) return undefined;
-    const resource: ProbeGpuResource = {
-      fact,
-      index,
-      filter: createProbeFilterState({ probeIndex: index, mipCount: PREFILTER_MIP_LEVELS }),
-      rawFaceCursor: 0,
-      raw,
-      active: undefined,
-      candidate,
-      spare,
-      sampler: this.shared.sampler,
-      uniformBuffer: uniformBuffer.value,
-      filterGroup1: filterGroup1.value,
-    };
-    this.resources.set(key, resource);
-    return resource;
-  }
-
-  private createSharedResources(filterPipeline: RenderPipeline): ProbeSharedResources | undefined {
-    const faceUniforms = createFaceUniformsBuffer(this.internals.device);
-    const prefilterUniforms = createPrefilterUniformsBuffer(this.internals.device);
-    if (!faceUniforms.ok || !prefilterUniforms.ok) return undefined;
-    if (!writeAllFaceUniforms(this.internals.device, faceUniforms.value).ok) return undefined;
-    if (!writeAllPrefilterUniforms(this.internals.device, prefilterUniforms.value).ok)
-      return undefined;
-    const vertexBuffer = this.internals.device.createBuffer({
-      label: 'reflection-probe-capture-cube-vertices',
-      size: CUBEMAP_FACE_VERTICES.byteLength,
-      usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
-      mappedAtCreation: false,
-    });
-    if (!vertexBuffer.ok) return undefined;
-    const vertexWrite = this.internals.device.queue.writeBuffer(
-      vertexBuffer.value,
-      0,
-      CUBEMAP_FACE_VERTICES,
-    );
-    if (!vertexWrite.ok) return undefined;
-    const sampler = this.internals.device.createSampler({
-      label: 'reflection-probe-pmrem-sampler',
-      magFilter: 'linear',
-      minFilter: 'linear',
-      mipmapFilter: 'linear',
-      addressModeU: 'clamp-to-edge',
-      addressModeV: 'clamp-to-edge',
-      addressModeW: 'clamp-to-edge',
-    });
-    const cache = getOrCreateIblCache(this.internals.deviceScope);
-    if (
-      !sampler.ok ||
-      cache.cubeGroup1Bgl === undefined ||
-      cache.prefilterGroup0Bgl === undefined
-    ) {
-      return undefined;
-    }
-    return {
-      faceUniforms: faceUniforms.value,
-      prefilterUniforms: prefilterUniforms.value,
-      vertexBuffer: vertexBuffer.value,
-      sampler: sampler.value,
-      filterPipeline,
-      cubeGroup1Bgl: cache.cubeGroup1Bgl,
-      prefilterGroup0Bgl: cache.prefilterGroup0Bgl,
-    };
-  }
-
-  private createCubeSet(label: string, requestedSize: number): ProbeCubeSet | undefined {
-    const size = Math.min(Math.max(1, Math.floor(requestedSize)), PREFILTER_SIZE);
-    const mipCount = Math.min(PREFILTER_MIP_LEVELS, Math.floor(Math.log2(size)) + 1);
-    const texture = this.internals.device.createTexture({
-      label,
-      size: { width: size, height: size, depthOrArrayLayers: 6 },
-      mipLevelCount: mipCount,
-      sampleCount: 1,
-      dimension: '2d',
-      format: this.outputFormat,
-      usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING | GPU_TEXTURE_USAGE_COPY_SRC,
-      viewFormats: [],
-      textureBindingViewDimension: undefined,
-    });
-    if (!texture.ok) return undefined;
-    const cubeView = this.internals.device.createTextureView(texture.value, {
-      label: `${label}-cube`,
-      dimension: 'cube',
-      baseMipLevel: 0,
-      mipLevelCount: mipCount,
-      arrayLayerCount: 6,
-    });
-    if (!cubeView.ok) return undefined;
-    const faceViews: TextureView[] = [];
-    const mipViews: TextureView[][] = [];
-    for (let mip = 0; mip < mipCount; mip += 1) {
-      const faces: TextureView[] = [];
-      for (let face = 0; face < 6; face += 1) {
-        const view = this.internals.device.createTextureView(texture.value, {
-          label: `${label}-mip${mip}-face${face}`,
-          dimension: '2d',
-          baseMipLevel: mip,
-          mipLevelCount: 1,
-          baseArrayLayer: face,
-          arrayLayerCount: 1,
-        });
-        if (!view.ok) return undefined;
-        if (mip === 0) faceViews.push(view.value);
-        faces.push(view.value);
-      }
-      mipViews.push(faces);
-    }
-    const depthTexture = this.internals.device.createTexture({
-      label: `${label}-depth`,
-      size: { width: size, height: size, depthOrArrayLayers: 1 },
-      mipLevelCount: 1,
-      sampleCount: 1,
-      dimension: '2d',
-      format: 'depth24plus-stencil8',
-      usage: 0x10,
-      viewFormats: [],
-      textureBindingViewDimension: undefined,
-    });
-    if (!depthTexture.ok) return undefined;
-    const depthView = this.internals.device.createTextureView(depthTexture.value, {
-      label: `${label}-depth-view`,
-      dimension: '2d',
-    });
-    if (!depthView.ok) return undefined;
-    return {
-      texture: texture.value,
-      cubeView: cubeView.value,
-      faceViews,
-      mipViews,
-      depthTexture: depthTexture.value,
-      depthView: depthView.value,
-      size,
-    };
-  }
-}
-
 export function createRenderSystem(internals: RenderSystemInternals): RenderSystem {
   const phaseCatalogRegistration = internals.profiler?.registerPhaseCatalog(
     'render',
@@ -1578,6 +1128,38 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let latestCamera: CameraSnapshot | undefined;
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
   const reflectionProbeOwner = new ReflectionProbeRecordOwner(internals);
+  let ssrFormatReceipt: import('@forgeax/engine-rhi').RhiTextureFormatCapabilityReceipt | undefined;
+  let ssrFormatProbeGeneration = -1;
+  let ssrFormatProbe: Promise<void> | undefined;
+  let ssrFallbackGeneration: number | undefined;
+  const ensureSsrFormatProbe = (): void => {
+    if (internals.ssrIdentity === undefined) return;
+    const generation = internals.deviceScope.generation;
+    if (
+      ssrFormatReceipt?.deviceGeneration === generation ||
+      ssrFormatProbeGeneration === generation ||
+      ssrFormatProbe !== undefined ||
+      typeof internals.device.probeTextureFormatCapability !== 'function'
+    ) {
+      return;
+    }
+    ssrFormatProbeGeneration = generation;
+    const device = internals.device;
+    ssrFormatProbe = device
+      .probeTextureFormatCapability()
+      .then((result) => {
+        if (internals.device !== device || internals.deviceScope.generation !== generation) return;
+        ssrFormatReceipt = result.ok ? result.value : undefined;
+      })
+      .catch(() => {
+        if (internals.device === device && internals.deviceScope.generation === generation) {
+          ssrFormatReceipt = undefined;
+        }
+      })
+      .finally(() => {
+        ssrFormatProbe = undefined;
+      });
+  };
   const cubeCaptureScheduler = createCubeCaptureScheduler({ maxFacesPerFrame: 1 });
   const cubeCaptureState: CubeCaptureGraphState = { work: [] };
   const persistentRenderScene = new PersistentRenderScene({
@@ -1725,6 +1307,23 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         ),
     } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory);
   let gpuDrivenProduction = new GpuDrivenProduction(internals.device, gpuDrivenShaderFactory);
+  let occlusionRuntime: OcclusionRenderRuntime | undefined = new OcclusionRenderRuntime(
+    internals.device,
+    persistentRenderScene.visibilityFacetStore(),
+    gpuDrivenShaderFactory,
+    persistentRenderScene.visibilityBudgetValue(),
+  );
+  const ensureOcclusionRuntime = (): OcclusionRenderRuntime => {
+    if (occlusionRuntime === undefined) {
+      occlusionRuntime = new OcclusionRenderRuntime(
+        internals.device,
+        persistentRenderScene.visibilityFacetStore(),
+        gpuDrivenShaderFactory,
+        persistentRenderScene.visibilityBudgetValue(),
+      );
+    }
+    return occlusionRuntime;
+  };
   const featureGpuWork: RenderFeatureGpuWorkOwner = createRenderFeatureGpuWorkOwner({
     getDevice: () => internals.device,
     getShaderModuleFactory: () =>
@@ -1772,11 +1371,13 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   // raw (material-handle-based, cross-world collision semantically correct).
   const frameState: RenderFrameState = {
     frameNumber: 0,
+    reflectionFallbackDemand: false,
     graphGeneration: 0,
     successfulTemporalFrameIndex: 0,
     lastSuccessfulBloom: 'off',
     temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
     temporalFrameInput: undefined,
+    reflectionFallbackReadback: undefined,
     directionalShadowCache: null,
     directionalShadowCacheRecorded: false,
     compiledFrameGraph: null,
@@ -1798,6 +1399,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     volumetricFogHistorySignature: null,
     retiredCompiledFrameGraphs: new Set(),
     currentFrameObservationSource: undefined,
+    reflectionFallbackObservationSource: undefined,
     lastSuccessfulCameraAntialias: undefined,
     temporalGpuState: undefined,
     activeTemporalGpuState: undefined,
@@ -1809,6 +1411,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     currentDirectionalShadowView: null,
     currentSpotShadowView: null,
     instanceBuffers: new Map(),
+    probeBlendBuffers: new Map(),
+    probeBlendRecordBufferCapacity: 0,
     morphBuffers: new Map(),
     hdrpClusterBinScratch: createClusterBinScratch(),
     hdrpClusterGridScratch: null,
@@ -1820,8 +1424,6 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     transientInstanceBuffers: [],
     warnedZeroLightStandard: false,
     warnedMultiLightDirectional: false,
-    warnedMultiLightPoint: false,
-    warnedMultiLightSpot: false,
     // feat-20260630-equirect-kind-internalized-ibl-declarative-skyligh M3 / w19:
     // once-warn latches for >1 Skylight / >1 SkyboxBackground (names winner).
     warnedMultiSkylight: false,
@@ -2104,6 +1706,134 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   const dispatchCounts: { unlit: number } = {
     unlit: 0,
   };
+  let lastLodOcclusionInspection: LodOcclusionInspection | undefined;
+  // The GPU selector returns stable numeric World keys with its same-submit
+  // counters. Keep the attachment join from that submit, rather than using
+  // the current worlds[] position when the asynchronous readback completes.
+  let lastLodWorldAttachments: ReadonlyMap<number, string> = new Map();
+  let occlusionCandidateCache:
+    | {
+        readonly renderables: readonly RenderableSnapshot[];
+        readonly camera: CameraSnapshot;
+        readonly cameraWorldIdentity: string;
+        readonly candidates: readonly OcclusionRuntimeCandidate[];
+      }
+    | undefined;
+  let lodCandidateCountCache:
+    | { readonly renderables: readonly RenderableSnapshot[]; readonly count: number }
+    | undefined;
+  let lodInspectionRenderablesCache:
+    | {
+        readonly submissionRenderables: readonly RenderableSnapshot[];
+        readonly lodCandidateCount: number;
+        readonly values: readonly RenderableSnapshot[];
+      }
+    | undefined;
+  let orderedDispatchCache:
+    | {
+        readonly source: readonly DispatchEntry[];
+        readonly world: World;
+        readonly camera: readonly CameraSnapshot[];
+        readonly renderables: readonly RenderableSnapshot[];
+        readonly value: readonly DispatchEntry[];
+      }
+    | undefined;
+  const applyLodSelectionTelemetry = (
+    selection:
+      | {
+          readonly candidateCount: number;
+          readonly visible: number;
+          readonly occluded: number;
+          readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+          readonly worldSelections?: readonly {
+            readonly worldKey: number;
+            readonly primitiveSlot: number;
+            readonly slotGeneration: number;
+            readonly candidateCount: number;
+            readonly visible: number;
+            readonly occluded: number;
+            readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+          }[];
+        }
+      | undefined,
+  ): void => {
+    if (selection === undefined || lastLodOcclusionInspection === undefined) return;
+    const inspection = lastLodOcclusionInspection;
+    // The GPU readback histogram is the selector fact, while final submitted
+    // counts are owned by the persistent visibility projection. Keeping the
+    // projection count here excludes ordinary non-LOD geometry (for example a
+    // benchmark occluder) from the LOD workload without inventing a second
+    // visibility owner or mixing CPU/GPU admission decisions.
+    let worlds = inspection.worlds;
+    const worldSelections = selection.worldSelections;
+    if (worldSelections !== undefined && worldSelections.length > 0) {
+      const selectionsByAttachment = new Map<string, (typeof worldSelections)[number][]>();
+      let attributionValid = true;
+      for (const selected of worldSelections) {
+        const attachmentId = lastLodWorldAttachments.get(selected.worldKey);
+        if (attachmentId === undefined) {
+          attributionValid = false;
+          break;
+        }
+        const rows = selectionsByAttachment.get(attachmentId);
+        if (rows === undefined) selectionsByAttachment.set(attachmentId, [selected]);
+        else rows.push(selected);
+      }
+      if (attributionValid) {
+        const nextWorlds = worlds.map((world) => {
+          const selected = selectionsByAttachment.get(world.attachmentId);
+          const baseRow = world.rows[0];
+          if (selected === undefined || baseRow === undefined) {
+            if (world.rows.length > 0) attributionValid = false;
+            return world;
+          }
+          const candidateCount = selected.reduce((sum, row) => sum + row.candidateCount, 0);
+          if (candidateCount !== baseRow.count.candidates) {
+            attributionValid = false;
+            return world;
+          }
+          return Object.freeze({
+            ...world,
+            attribution: Object.freeze({
+              status: 'same-submit' as const,
+              submit: inspection.submit,
+            }),
+            rows: Object.freeze(
+              selected.map((row) => ({
+                ...baseRow,
+                slot: {
+                  primitiveSlot: row.primitiveSlot,
+                  slotGeneration: row.slotGeneration,
+                },
+                count: {
+                  candidates: row.candidateCount,
+                  visible: row.visible,
+                  occluded: row.occluded,
+                },
+                lodHistogram: row.lodHistogram,
+              })),
+            ),
+          });
+        });
+        if (attributionValid) worlds = Object.freeze(nextWorlds);
+      }
+    }
+    lastLodOcclusionInspection = inspectLodOcclusion({
+      ...inspection,
+      count: {
+        ...lastLodOcclusionInspection.count,
+        candidates: selection.candidateCount,
+        visible: selection.visible,
+        occluded: selection.occluded,
+      },
+      lodHistogram: selection.lodHistogram,
+      // Per-primitive samples are intentionally omitted until the GPU readback
+      // carries stable primitive identities; the histogram is the authoritative
+      // producer fact and is copied from the same GPU cull counters.
+      samples: [],
+      worlds,
+    });
+  };
   // feat-20260531-per-frame-bind-group-cache M1 / w4: per-frame
   // createBindGroup counter scaffolding. Reset on every draw([world], { cameraOwner: 0, resourceOwner: 0 }) entry,
   // bumped on cache-miss in render-system-record.ts (M2-M4 bump points).
@@ -2466,9 +2196,44 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         gpuDriven: gpuDrivenProduction.inspect(),
       };
     },
+    get gpuDrivenInspection(): GpuDrivenProductionInspection {
+      return gpuDrivenProduction.inspect();
+    },
     get reflectionProbes(): ReflectionProbeInspection {
       return reflectionProbeOwner.inspect();
     },
+    get ssrDependencies(): SsrDependenciesInspection {
+      ensureSsrFormatProbe();
+      const owner = reflectionProbeOwner.inspect();
+      const nextGeneration = owner.reflectionFallback.projectionGeneration;
+      const reset = resolveSsrAdmissionGeneration(ssrFallbackGeneration, nextGeneration);
+      if (reset.changed) {
+        frameState.temporalFrameTransaction.reset('signature-change');
+        frameState.temporalFrame = undefined;
+        frameState.temporalFrameInput = undefined;
+        frameState.lastSuccessfulTemporalView = undefined;
+        frameState.successfulTemporalFrameIndex = 0;
+        frameState.pendingTemporalCommit = { kind: 'none' };
+      }
+      ssrFallbackGeneration = reset.generation;
+      const temporal =
+        frameState.lastSuccessfulTemporalView === undefined
+          ? undefined
+          : ({
+              successfulSubmit: true,
+              generation: frameState.lastSuccessfulTemporalView.input.deviceGeneration,
+            } as const);
+      return projectSsrDependencies({
+        requested: frameState.reflectionFallbackDemand === true,
+        identity: internals.ssrIdentity,
+        reflectionFallback: owner.reflectionFallback,
+        format: ssrFormatReceipt,
+        temporal,
+      });
+    },
+    get reflectionFallbackCompletion(): Promise<void> | undefined {
+      return frameState.reflectionFallbackCompletion;
+    },
     isCubeCapturePending(target: RenderTarget): boolean {
       return cubeCaptureScheduler.inspect(target).candidateGeneration !== undefined;
     },
@@ -2538,6 +2303,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         }),
       });
     },
+    get lodOcclusionInspection(): LodOcclusionInspection | undefined {
+      return lastLodOcclusionInspection;
+    },
     get bloom(): BloomInspection {
       const pipelineState = internals.getPipelineState();
       const resources = pipelineState?.perPassResources;
@@ -2676,14 +2444,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             worlds,
             { cameraOwner, resourceOwner },
             internals.assets.catalogEpoch,
-            () =>
+            (renderables) =>
               extractFrames(
                 worlds,
                 { cameraOwner, resourceOwner },
                 internals.assets,
                 internals.getPipelineState(),
                 persistentRenderScene.materialSnapshotCacheStore(),
-                { cull: 'none' },
+                {
+                  cull: 'none',
+                  renderables,
+                  ...(internals.getMaterialShaderArtifact === undefined
+                    ? {}
+                    : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }),
+                },
               ),
             renderReadLeases,
           );
@@ -2701,7 +2475,6 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           skylightCount,
           skybox,
           skyboxCount,
-          fog,
           fogFailure,
           frustumStats,
           visibilityStats,
@@ -2714,12 +2487,279 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           frame.reflectionProbes ?? [],
           persistentRenderScene.reflectionProbeProjection().selected,
           cameras[0],
+          frameState.frameNumber,
+          skylight,
         );
         latestCamera = cameras[0];
+        persistentRenderScene.updateVisibilityFacet(worlds, latestCamera, renderables);
+        let occlusionProjection:
+          | import('./scene/visibility/occlusion-runtime').OcclusionFrameProjection
+          | undefined;
+        let occlusionFallback: LodOcclusionInspection['fallback'] = { active: false };
+        const worldKeys = persistentRenderScene.visibilityWorldKeysFor(worlds);
+        const slotByEntity = persistentRenderScene.compositionSlotByStableEntity();
+        if (latestCamera !== undefined) {
+          const camera = latestCamera;
+          const cameraWorld = worlds[camera.worldId ?? cameraOwner];
+          const view = viewKey({
+            attachmentId: cameraWorld?.identity ?? 'missing-camera-world',
+            cameraEntity: camera.entityKey ?? 0,
+            viewRole: 'main',
+            viewGeneration: camera.historyVersion ?? 0,
+          });
+          const cachedCandidates = occlusionCandidateCache;
+          const candidates =
+            cachedCandidates?.renderables === renderables &&
+            cachedCandidates.camera === camera &&
+            cachedCandidates.cameraWorldIdentity === (cameraWorld?.identity ?? '')
+              ? cachedCandidates.candidates
+              : renderables.flatMap((renderable) => {
+                  const world = worlds[renderable.worldId];
+                  const aabb = renderable.localAabb;
+                  // Occlusion is a LOD transport concern. A plain mesh has no
+                  // lower-detail range to select, so keep it on the ordinary CPU
+                  // visibility path and do not allocate query resources for it.
+                  if (
+                    world === undefined ||
+                    cameraWorld === undefined ||
+                    aabb === undefined ||
+                    aabb.length < 6 ||
+                    renderable.lods === undefined ||
+                    renderable.lods.length === 0
+                  )
+                    return [];
+                  const slot = slotByEntity.get(
+                    worldEntityKey(
+                      worldKeys[renderable.worldId] ?? renderable.worldId,
+                      renderable.entityKey,
+                    ),
+                  );
+                  if (slot === undefined) return [];
+                  const primitive = primitiveKey({
+                    attachmentId: cameraWorld.identity,
+                    worldGeneration: worldKeys[renderable.worldId] ?? renderable.worldId,
+                    primitiveSlot: slot.slot,
+                    slotGeneration: slot.generation,
+                  });
+                  return [
+                    {
+                      view,
+                      primitive,
+                      epoch: 0,
+                      bounds: {
+                        min: [aabb[0] ?? 0, aabb[1] ?? 0, aabb[2] ?? 0] as [number, number, number],
+                        max: [aabb[3] ?? 0, aabb[4] ?? 0, aabb[5] ?? 0] as [number, number, number],
+                      },
+                      candidate: { level: 0, confidence: 1 },
+                      deviceGeneration: internals.deviceScope.generation,
+                      proxyVertices: buildOcclusionProxyVertices(
+                        aabb,
+                        renderable.transform.world,
+                        camera,
+                      ),
+                    },
+                  ];
+                });
+          occlusionCandidateCache = {
+            renderables,
+            camera,
+            cameraWorldIdentity: cameraWorld?.identity ?? '',
+            candidates,
+          };
+          occlusionProjection = runProfiledRenderPhase(profileSession, 'occlusion-prepare', () =>
+            ensureOcclusionRuntime().prepareBatch(candidates, camera.antialias === 'msaa' ? 4 : 1),
+          );
+          const queryPool = ensureOcclusionRuntime().inspect();
+          const queryUnavailable = ensureOcclusionRuntime().prepareUnavailable;
+          const queryCapacityFallback =
+            candidates.length > 0 && queryUnavailable && queryPool.availablePages === 0;
+          occlusionFallback = queryCapacityFallback
+            ? {
+                active: true as const,
+                reason: 'page-exhausted' as const,
+                error: {
+                  code: 'visibility-query-capacity-exhausted',
+                  expected: 'one available occlusion-query page for the LOD candidate batch',
+                  hint: 'retry the LOD query after an in-flight page completes',
+                  detail: {
+                    availablePages: queryPool.availablePages,
+                    pageCount: queryPool.pageCount,
+                    pageIndexLimit: queryPool.pageIndexLimit,
+                  },
+                },
+              }
+            : ({ active: false } as const);
+        }
+        // Query transport is best-effort and must fail open. A candidate that
+        // was hidden by an earlier completion becomes visible again when this
+        // device/frame cannot reserve a fresh query page; the next successful
+        // submission can rebuild confidence from a real result.
+        if (
+          occlusionProjection === undefined &&
+          latestCamera !== undefined &&
+          ensureOcclusionRuntime().prepareUnavailable
+        ) {
+          const cameraWorld = worlds[latestCamera.worldId ?? cameraOwner];
+          if (cameraWorld !== undefined) {
+            const fallbackView = viewKey({
+              attachmentId: cameraWorld.identity,
+              cameraEntity: latestCamera.entityKey ?? 0,
+              viewRole: 'main',
+              viewGeneration: latestCamera.historyVersion ?? 0,
+            });
+            for (const renderable of renderables) {
+              if ((renderable.lods?.length ?? 0) === 0) continue;
+              const world = worlds[renderable.worldId];
+              if (world === undefined) continue;
+              const slot = slotByEntity.get(
+                worldEntityKey(
+                  worldKeys[renderable.worldId] ?? renderable.worldId,
+                  renderable.entityKey,
+                ),
+              );
+              if (slot === undefined) continue;
+              persistentRenderScene.visibilityFacetStore().applyConfidence(
+                fallbackView,
+                primitiveKey({
+                  attachmentId: cameraWorld.identity,
+                  worldGeneration: worldKeys[renderable.worldId] ?? renderable.worldId,
+                  primitiveSlot: slot.slot,
+                  slotGeneration: slot.generation,
+                }),
+                { type: 'failure', submissionGeneration: frameState.frameNumber },
+              );
+            }
+          }
+        }
+        const visibilityProjection = persistentRenderScene.projectVisibility(
+          worlds,
+          latestCamera,
+          renderables,
+          dispatch,
+        );
+        const submissionRenderables = visibilityProjection.renderables;
+        const submissionDispatch = visibilityProjection.dispatch;
+        const inspectionCamera = latestCamera;
+        let lodCandidateCountForFrame = 0;
+        if (inspectionCamera !== undefined) {
+          const firstRenderable = renderables[0];
+          const lodCandidateCount =
+            lodCandidateCountCache?.renderables === renderables
+              ? lodCandidateCountCache.count
+              : (() => {
+                  const count = renderables.reduce(
+                    (total, renderable) => total + ((renderable.lods?.length ?? 0) > 0 ? 1 : 0),
+                    0,
+                  );
+                  lodCandidateCountCache = { renderables, count };
+                  return count;
+                })();
+          lodCandidateCountForFrame = lodCandidateCount;
+          const inspectionRenderables =
+            lodInspectionRenderablesCache?.submissionRenderables === submissionRenderables &&
+            lodInspectionRenderablesCache.lodCandidateCount === lodCandidateCount
+              ? lodInspectionRenderablesCache.values
+              : (() => {
+                  const values =
+                    lodCandidateCount > 0
+                      ? submissionRenderables.filter(
+                          (renderable) => (renderable.lods?.length ?? 0) > 0,
+                        )
+                      : submissionRenderables;
+                  lodInspectionRenderablesCache = {
+                    submissionRenderables,
+                    lodCandidateCount,
+                    values,
+                  };
+                  return values;
+                })();
+          const candidateCount =
+            lodCandidateCount > 0 ? lodCandidateCount : renderables.length + frustumStats.culled;
+          const inspectionQuery = ensureOcclusionRuntime().inspect();
+          const inspectionBudget = persistentRenderScene.visibilityBudgetValue();
+          const inspectionWorlds = createLodWorldInspections(
+            worlds,
+            renderables,
+            submissionRenderables,
+            inspectionCamera,
+            frameState.frameNumber,
+            worldKeys,
+            slotByEntity,
+            {
+              used:
+                inspectionQuery.pageCount * inspectionQuery.pageIndexLimit -
+                inspectionQuery.availablePages * inspectionQuery.pageIndexLimit,
+              capacity: inspectionQuery.pageCount * inspectionQuery.pageIndexLimit,
+            },
+            occlusionFallback,
+            ensureOcclusionRuntime().prepareUnavailable
+              ? { active: true, reason: 'query-unavailable' as const }
+              : { active: false },
+          );
+          const attachmentByWorldKey = new Map<number, string>();
+          for (let worldId = 0; worldId < worlds.length; worldId += 1) {
+            const world = worlds[worldId];
+            if (world === undefined) continue;
+            const worldKey = worldKeys[worldId] ?? worldId;
+            if (attachmentByWorldKey.has(worldKey)) {
+              attachmentByWorldKey.clear();
+              break;
+            }
+            attachmentByWorldKey.set(worldKey, world.identity);
+          }
+          lastLodWorldAttachments = attachmentByWorldKey;
+          lastLodOcclusionInspection = inspectLodOcclusion({
+            root: {
+              guid:
+                firstRenderable === undefined
+                  ? 'none'
+                  : `asset-handle:${firstRenderable.assetHandle}`,
+              sourceKey: `render-frame:${frameState.frameNumber}`,
+            },
+            view: {
+              attachmentId: worlds[inspectionCamera.worldId ?? cameraOwner]?.identity ?? 'none',
+              cameraEntity: inspectionCamera.entityKey ?? 0,
+              viewRole: 'main',
+              viewGeneration: inspectionCamera.historyVersion ?? 0,
+            },
+            slot: {
+              primitiveSlot: 0,
+              slotGeneration: persistentRenderScene.inspect().topology.revision,
+            },
+            generation: frameState.frameNumber,
+            count: {
+              candidates: candidateCount,
+              visible: inspectionRenderables.length,
+              occluded: visibilityProjection.suppressed,
+            },
+            lodHistogram: [{ level: 0, count: inspectionRenderables.length }],
+            queryLatencyUs: { median: 0, p95: 0, last: 0 },
+            pagePressure: { used: 0, capacity: 3 * 4096 },
+            fallback: occlusionFallback,
+            degradation: ensureOcclusionRuntime().prepareUnavailable
+              ? { active: true, reason: 'query-unavailable' as const }
+              : { active: false },
+            samples: inspectionRenderables.slice(0, 64).map((_, index) => ({
+              primitiveSlot: index,
+              level: 0,
+              visible: true,
+            })),
+            submit: {
+              frameId: frameState.frameNumber,
+              build: resolveInspectionBuild(internals),
+              deviceGeneration: internals.deviceScope.generation,
+            },
+            budget: inspectionBudget,
+            worlds: inspectionWorlds,
+          });
+        } else {
+          lastLodOcclusionInspection = undefined;
+          lastLodWorldAttachments = new Map();
+        }
         const temporalDemanded =
           cameras[0]?.antialias === 'taa' || (cameras[0]?.motionBlur?.shutterAngle ?? 0) > 0;
         if (temporalDemanded) {
-          persistentRenderScene.prepareTemporalFrame(renderables);
+          persistentRenderScene.prepareTemporalFrame(submissionRenderables);
         }
         environmentLifecycle.bindScope(internals.deviceScope);
         if (fogFailure !== undefined) {
@@ -2897,9 +2937,31 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         // world that owns skylight / skybox / singleton render state, w5 / D-3).
         // Only the Transparent segment is reordered; queue ordering between
         // segments (sortDispatchByQueue, stable) is preserved.
-        const orderedDispatch = runProfiledRenderPhase(profileSession, 'sort', () =>
-          sortTransparentDispatch(dispatch, resourceWorld, cameras, renderables),
-        );
+        const orderedDispatch = runProfiledRenderPhase(profileSession, 'sort', () => {
+          const cached = orderedDispatchCache;
+          if (
+            cached?.source === submissionDispatch &&
+            cached.world === resourceWorld &&
+            cached.camera === cameras &&
+            cached.renderables === submissionRenderables
+          ) {
+            return cached.value;
+          }
+          const value = sortTransparentDispatch(
+            [...submissionDispatch],
+            resourceWorld,
+            cameras,
+            submissionRenderables,
+          );
+          orderedDispatchCache = {
+            source: submissionDispatch,
+            world: resourceWorld,
+            camera: cameras,
+            renderables: submissionRenderables,
+            value,
+          };
+          return value;
+        });
 
         // M3 / w26: single dispatch list replaces old three-bucket model.
         // Pass dispatch to recordFrame — the record stage iterates dispatch
@@ -2927,13 +2989,16 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 // The same runner is also called by geometry/material helpers;
                 // invoking those wrappers would turn a pass probe into the
                 // high-overhead per-draw `nested` probe.
-                if (
-                  profileSession.detail === 'passes' &&
-                  (!phase.startsWith('record/graph-execute/') ||
-                    (phase.slice('record/graph-execute/'.length).includes('/') &&
-                      !phase.endsWith('/geometry-loop')))
-                ) {
-                  return action();
+                if (profileSession.detail === 'passes') {
+                  const isOcclusionOwner =
+                    phase === 'record/occlusion-query-submit' ||
+                    phase === 'record/occlusion-global-advance';
+                  const isGraphOwner =
+                    phase === 'record/graph-execute' ||
+                    (phase.startsWith('record/graph-execute/') &&
+                      (!phase.slice('record/graph-execute/'.length).includes('/') ||
+                        phase.endsWith('/geometry-loop')));
+                  if (!isOcclusionOwner && !isGraphOwner) return action();
                 }
                 return runProfiledRenderPhase(profileSession, phase, action);
               };
@@ -2946,7 +3011,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             resourceWorld,
             cameras,
             lights,
-            renderables,
+            [...submissionRenderables],
             orderedDispatch,
             frameState,
             dispatchCounts,
@@ -2956,16 +3021,18 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             skybox,
             skyboxCount,
             postProcessParams,
-            fog,
             worlds,
             recordProfilePhase,
             {
               owner: gpuDrivenProduction,
               scene: persistentRenderScene.compositionGpuDrivenState(),
-              onCoverage: (ownsAll, clusteredLighting) => {
-                const key = `${internals.gpuStore.meshResidencyEpoch}:${clusteredLighting ? 'clustered' : 'standard'}`;
-                persistentRenderScene.setCompositionGpuDrivenCoverage(key, ownsAll);
+              onSceneDemand: (sceneRowsRequired) => {
+                persistentRenderScene.setCompositionGpuSceneDemand(sceneRowsRequired);
               },
+              activeEntityKeys: visibilityProjection.activeEntityKeys,
+              activeEntityRevision: visibilityProjection.activeEntityRevision,
+              telemetryCandidateCount: lodCandidateCountForFrame,
+              ...(occlusionProjection === undefined ? {} : { occlusion: occlusionProjection }),
             },
             renderReadLeases,
             featureGraphCandidate,
@@ -2984,6 +3051,22 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             timingCapture,
           ),
         );
+        if (submitted && lastLodOcclusionInspection !== undefined) {
+          const query = ensureOcclusionRuntime().inspect();
+          lastLodOcclusionInspection = {
+            ...lastLodOcclusionInspection,
+            pagePressure: {
+              used:
+                query.pageCount * query.pageIndexLimit -
+                query.availablePages * query.pageIndexLimit,
+              capacity: query.pageCount * query.pageIndexLimit,
+            },
+            fallback: occlusionFallback,
+            degradation: ensureOcclusionRuntime().prepareUnavailable
+              ? { active: true, reason: 'query-unavailable' as const }
+              : { active: false },
+          };
+        }
         const directionalQuality = lights.directionalShadowQuality;
         const directionalShadowReady =
           directionalQuality === undefined ||
@@ -3007,6 +3090,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           };
         }
         if (submitted) {
+          if (occlusionProjection === undefined) {
+            runProfiledRenderPhase(profileSession, 'record/occlusion-global-advance', () =>
+              ensureOcclusionRuntime().advanceSuccessfulSubmit(frameState.frameNumber),
+            );
+          }
           const temporalCommit = persistentRenderScene.commitTemporalFrame();
           if (!temporalCommit.ok) {
             internals.errorRegistry.fire(temporalCommit.error);
@@ -3085,6 +3173,21 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const currentFrameId = frameState.frameNumber - 1;
       return observeCurrentFrame(options, frameState.currentFrameObservationSource, currentFrameId);
     },
+    async observeLodOcclusion(): Promise<void> {
+      await ensureOcclusionRuntime().waitForCompletions();
+      applyLodSelectionTelemetry(await gpuDrivenProduction.readLodSelection());
+      if (lastLodOcclusionInspection !== undefined) {
+        const queryLatency = ensureOcclusionRuntime().inspectQueryLatency();
+        lastLodOcclusionInspection = inspectLodOcclusion({
+          ...lastLodOcclusionInspection,
+          queryLatencyUs: {
+            median: queryLatency.median,
+            p95: queryLatency.p95,
+            last: queryLatency.last,
+          },
+        });
+      }
+    },
     getCurrentGraphTarget(name: string) {
       const graph = frameState.perFrameGraph;
       if (graph === undefined || graph === null) return undefined;
@@ -3236,6 +3339,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       (internals as TimingSessionHost).gpuPassTimingBeginReason = undefined;
       persistentRenderScene.dispose();
       gpuDrivenProduction.dispose();
+      occlusionRuntime?.dispose();
       disposeFeatureGpuWork();
       reflectionProbeOwner.dispose();
       // Bloom generations are renderer-owned rather than graph-owned. Drain
@@ -3304,6 +3408,15 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // dispose error strategy).
       disposeInstanceBuffers(frameState.instanceBuffers, internals.errorRegistry);
       disposeTransientInstanceBuffers(frameState.transientInstanceBuffers, internals.errorRegistry);
+      if (frameState.probeBlendRecordBuffer !== undefined) {
+        if (!frameState.probeBlendRecordBuffer.isDestroyed) {
+          const result = frameState.probeBlendRecordBuffer.destroy();
+          if (!result.ok) internals.errorRegistry.fire(result.error);
+        }
+        delete frameState.probeBlendRecordBuffer;
+      }
+      frameState.probeBlendRecordBufferCapacity = 0;
+      frameState.probeBlendBuffers.clear();
       if (frameState.morphBuffers !== undefined) {
         for (const entry of frameState.morphBuffers.values()) {
           if (!entry.buffer.isDestroyed) {
@@ -3324,6 +3437,10 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       }
     },
     resetForRecover(): void {
+      ssrFormatReceipt = undefined;
+      ssrFormatProbeGeneration = -1;
+      ssrFormatProbe = undefined;
+      ssrFallbackGeneration = undefined;
       transmissionAdmission.markDeviceLost();
       lastTransmissionKey = '';
       transmissionCapabilityGeneration = -1;
@@ -3341,6 +3458,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       persistentRenderScene.resetGpuForRecover();
       gpuDrivenProduction.dispose();
       gpuDrivenProduction = new GpuDrivenProduction(internals.device, gpuDrivenShaderFactory);
+      occlusionRuntime?.dispose();
+      // The replacement device is installed by the host after this hook. Do
+      // not recreate device-bound query resources against the lost device;
+      // the first post-recovery frame lazily binds the current device.
+      occlusionRuntime = undefined;
       disposeFeatureGpuWork();
       reflectionProbeOwner.dispose();
       // A recovered device cannot retain handles from the lost device. The
@@ -3383,6 +3505,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = undefined;
       frameState.lastSuccessfulCameraAntialias = undefined;
+      frameState.temporalFrameTransaction.reset('device-recovery');
+      frameState.temporalFrame = undefined;
+      frameState.temporalFrameInput = undefined;
+      frameState.lastSuccessfulTemporalView = undefined;
+      frameState.successfulTemporalFrameIndex = 0;
+      frameState.pendingTemporalCommit = { kind: 'none' };
       frameState.currentDirectionalShadowView = null;
       frameState.currentSpotShadowView = null;
       if (frameState.temporalGpuState !== undefined) {
@@ -3403,6 +3531,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       }
       frameState.retiredCompiledFrameGraphs.clear();
       frameState.instanceBuffers.clear();
+      delete frameState.probeBlendRecordBuffer;
+      frameState.probeBlendRecordBufferCapacity = 0;
+      frameState.probeBlendBuffers.clear();
       frameState.morphBuffers?.clear();
       frameState.transientInstanceBuffers = [];
       frameState.pointShadowAtlas = null;
@@ -3470,6 +3601,71 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   };
 }
 
+function buildOcclusionProxyVertices(
+  aabb: ArrayLike<number>,
+  world: ArrayLike<number>,
+  camera: import('./render-contract').CameraSnapshot,
+): Float32Array {
+  const view = computeViewMatrix(camera);
+  const projection = computeProjectionMatrix(camera);
+  const viewProjection = mat4.create();
+  mat4.multiply(viewProjection, projection, view);
+  const corners = [
+    [aabb[0] ?? 0, aabb[1] ?? 0, aabb[2] ?? 0],
+    [aabb[3] ?? 0, aabb[1] ?? 0, aabb[2] ?? 0],
+    [aabb[3] ?? 0, aabb[4] ?? 0, aabb[2] ?? 0],
+    [aabb[0] ?? 0, aabb[4] ?? 0, aabb[2] ?? 0],
+    [aabb[0] ?? 0, aabb[1] ?? 0, aabb[5] ?? 0],
+    [aabb[3] ?? 0, aabb[1] ?? 0, aabb[5] ?? 0],
+    [aabb[3] ?? 0, aabb[4] ?? 0, aabb[5] ?? 0],
+    [aabb[0] ?? 0, aabb[4] ?? 0, aabb[5] ?? 0],
+  ];
+  const triangles = [
+    0, 1, 2, 0, 2, 3, 4, 6, 5, 4, 7, 6, 0, 4, 5, 0, 5, 1, 3, 2, 6, 3, 6, 7, 0, 3, 7, 0, 7, 4, 1, 5,
+    6, 1, 6, 2,
+  ];
+  const output = new Float32Array(triangles.length * 4);
+  for (let index = 0; index < triangles.length; index += 1) {
+    const corner = corners[triangles[index] ?? 0] ?? [0, 0, 0];
+    const cx = corner[0] ?? 0;
+    const cy = corner[1] ?? 0;
+    const cz = corner[2] ?? 0;
+    const x = (world[0] ?? 0) * cx + (world[4] ?? 0) * cy + (world[8] ?? 0) * cz + (world[12] ?? 0);
+    const y = (world[1] ?? 0) * cx + (world[5] ?? 0) * cy + (world[9] ?? 0) * cz + (world[13] ?? 0);
+    const z =
+      (world[2] ?? 0) * cx + (world[6] ?? 0) * cy + (world[10] ?? 0) * cz + (world[14] ?? 0);
+    const w =
+      (world[3] ?? 0) * cx + (world[7] ?? 0) * cy + (world[11] ?? 0) * cz + (world[15] ?? 1);
+    const base = index * 4;
+    output[base] =
+      (viewProjection[0] ?? 0) * x +
+      (viewProjection[4] ?? 0) * y +
+      (viewProjection[8] ?? 0) * z +
+      (viewProjection[12] ?? 0) * w;
+    output[base + 1] =
+      (viewProjection[1] ?? 0) * x +
+      (viewProjection[5] ?? 0) * y +
+      (viewProjection[9] ?? 0) * z +
+      (viewProjection[13] ?? 0) * w;
+    output[base + 2] =
+      (viewProjection[2] ?? 0) * x +
+      (viewProjection[6] ?? 0) * y +
+      (viewProjection[10] ?? 0) * z +
+      (viewProjection[14] ?? 0) * w;
+    output[base + 3] =
+      (viewProjection[3] ?? 0) * x +
+      (viewProjection[7] ?? 0) * y +
+      (viewProjection[11] ?? 0) * z +
+      (viewProjection[15] ?? 0) * w;
+  }
+  return output;
+}
+
+/** Resolve the build identity used by every inspection submit. */
+export function resolveInspectionBuild(internals: Pick<RenderSystemInternals, 'build'>): string {
+  return internals.build ?? 'render-system';
+}
+
 // @forgeax/engine-render - built-in record context extension.
 //
 // The public RenderPipelineContext is canonical in render-contract.ts. This