@aura3d/engine 3.0.1 → 4.0.0

package/dist/rendering/Renderer.js

@@ -1,3 +1,13 @@
+import { collectEnvironmentBackground, collectEnvironmentFog, collectEnvironmentLighting } from "./renderer/Background.js";
+import { applyRendererOwnedStaticBatching, applyRendererOwnedStaticMeshConsolidation, cullExplicitRenderItems, culledCastersReachingView, explicitCullingFrustum } from "./renderer/CullingBatching.js";
+import { rendererDeviceIsLost, subscribeRendererDeviceLost, subscribeRendererDeviceRestored } from "./renderer/DeviceLifecycle.js";
+import { createRendererFrameHooks, toFrameCamera } from "./renderer/FrameGraph.js";
+import { RendererPostprocessPipeline, collectPostprocess, createPostprocessDiagnostics, defaultPostprocessTargetFormat, postGraphV2LastOutcome, postprocessRequiresDepthTexture } from "./renderer/PostprocessExecution.js";
+import { createRenderer } from "./renderer/RendererFactory.js";
+import { collectItemBounds, isIterable, renderableWorldBounds, sceneFromSource, toMat4 } from "./renderer/RenderShared.js";
+import { RendererShadowOrchestrator, collectForwardShadowMap, collectRendererShadowOptions } from "./renderer/ShadowOrchestration.js";
+import { shadowFrameCamera } from "./shadows/Prd02ShadowBridge.js";
+import {} from "./contracts/renderSource.js";
 import { Bounds3 as SceneBounds3, Camera, DirectionalLight, Light, PerspectiveCamera, PointLight, Scene, SpotLight, identityMat4, invertMat4, multiplyMat4, orthographicMat4, perspectiveMat4, transformPoint, toMathMat4 } from "../scene/index.js";
 import { Frustum } from "../math/index.js";
 import { createRenderDevice } from "./RenderBackend.js";
@@ -18,9 +28,35 @@ import { Sampler } from "./Sampler.js";
 import {} from "./Texture.js";
 import { TextureBinding } from "./TextureBinding.js";
 import { computeOrthographicCameraFrame, computePerspectiveCameraFrame } from "./CameraFraming.js";
+import { ResolutionGovernor } from "./ResolutionGovernor.js";
+import { frameStatsSlot } from "./contracts/device.js";
+import { resolveCanvasPixelRatio, watchDevicePixelRatio } from "./renderer/PixelRatio.js";
+import { QUALITY_TIERS } from "./contracts/quality.js";
+import { prd11LiveQualityTier } from "./quality/liveTier.js";
+import { MaterialInstance } from "./MaterialInstance.js";
+import { featuresForGeometry, materialRoutesToGeneratedProgram } from "./program/MaterialFeatures.js";
+import { selectShaderFeatureBits } from "./program/FeatureSelect.js";
+import { collectWarmupFeatures, ProgramWarmup } from "./program/ProgramWarmup.js";
+import { PRD03_EXPOSURE, rendererQrFlags, setRendererQrFlags, withRendererQrFlags } from "./renderer/FrameGraph.js";
+import { consumeTaaHistoryWritten } from "./renderer/postSkipped.js";
+import { qrCoreGeneratorOn, qrCoreOutputOn, qrGeneratedProgramsOn, qrMaterialsLobeProgramsOn, rendererOutputPass, rendererProgramCache } from "./renderer/qrSubFlags.js";
+import { resolveCoreOutputPostRoute, withCoreOutputOff } from "./renderer/coreOutputPostRoute.js";
+import { forwardPassFeatureAxes, prd02IblEnvironmentAvailable, splitForwardItems } from "./ForwardPass.js";
+import { PRD02_IBL_FEATURE } from "./contracts/environment.js";
+import { InterleavedTransparentPass } from "./renderer/InterleavedTransparentPass.js";
+import { ensureSceneDepthCopyTarget, SceneDepthCopyPass } from "./renderer/SceneDepthCopyPass.js";
+import { probeHdrTargetFormat, DEFAULT_TONE_MAPPING } from "./contracts/output.js";
+import { resolveForwardClusteredLighting } from "./forward/Lighting.js";
 import { assertRendererFeatures, createRendererFeatureReport } from "./RendererFeatureGates.js";
 import { batchStaticRenderItems } from "./SceneOptimization.js";
 import { createStaticMeshConsolidationCache } from "./MeshConsolidation.js";
+/**
+ * C-05 (PRD-01 §8.4-§8.6): output configuration applied by the OutputPass
+ * under `A3D_QR_CORE_OUTPUT`. Flag-off: recorded but never applied (legacy
+ * present path is untouched).
+ */
+/** #1140: OutputPass dithering default (three.js parity); `output.dithering` overrides. */
+export const DEFAULT_OUTPUT_DITHERING = false;
 export const DEFAULT_RENDERER_AUTO_FRAME_OPTIONS = {
     paddingRatio: 0.14,
     yawRadians: -0.38,
@@ -28,32 +64,6 @@ export const DEFAULT_RENDERER_AUTO_FRAME_OPTIONS = {
     nearPadding: 0.2,
     farPadding: 2.4
 };
-export const DEFAULT_RENDERER_ENVIRONMENT_LIGHTING = {
-    color: [0.78, 0.8, 0.84],
-    intensity: 0.42,
-    proceduralMap: {
-        skyColor: [0.64, 0.76, 0.94],
-        horizonColor: [0.94, 0.82, 0.62],
-        groundColor: [0.12, 0.13, 0.15],
-        specularColor: [1, 0.94, 0.78],
-        intensity: 0.5,
-        specularIntensity: 0.82
-    }
-};
-const DISABLED_RENDERER_ENVIRONMENT_LIGHTING = {
-    color: [0, 0, 0],
-    intensity: 0,
-    proceduralMap: {
-        skyColor: [0, 0, 0],
-        horizonColor: [0, 0, 0],
-        groundColor: [0, 0, 0],
-        specularColor: [0, 0, 0],
-        intensity: 0,
-        specularIntensity: 0
-    },
-    environmentMapIntensity: 0,
-    environmentMapSpecularIntensity: 0
-};
 export const DEFAULT_RENDERER_DIRECT_LIGHTING = {
     key: {
         color: [1, 0.92, 0.78],
@@ -66,10 +76,12 @@ export const DEFAULT_RENDERER_DIRECT_LIGHTING = {
         direction: [-0.35, -0.22, -0.91]
     }
 };
+export { DEFAULT_RENDERER_ENVIRONMENT_LIGHTING } from "./renderer/Background.js";
 export class Renderer {
     device;
     graph = new RenderGraph();
     shaderLibrary;
+    host;
     /**
      * Depth target reused by the renderer-owned shadow pass across frames.
      *
@@ -95,36 +107,190 @@ export class Renderer {
     width;
     height;
     clearColor;
+    outputClearColor;
     disposed = false;
     animationLoop = null;
     fusedLdrPostprocessScratch = {};
+    // §6.9 resolution policy state (present only when `options.resolution` is set).
+    resolutionOptions;
+    qualityTier;
+    qualityTierName;
+    programWarmup;
+    /** C-05 state: requested output options, the resolved HDR scene target, and the depth copy. */
+    outputOptions;
+    hdrSceneTarget = null;
+    hdrMsaaMrtDegraded = false;
+    sceneDepthCopyTarget = null;
+    lastAppliedOutput = null;
+    warnedV2Postprocess = false;
+    /** T0-07: C-36-shaped record of the last legacy postprocess chain skipped
+     *  under A3D_QR_CORE_OUTPUT (`null` when nothing was skipped). Read by the
+     *  engine's C-31 `output.postSkipped` section; routing through PostGraph v2
+     *  is lane 03's Q-03-2/Q-03-3. */
+    lastPostSkipped = null;
+    get postSkipped() {
+        return this.lastPostSkipped;
+    }
+    warnPostLegacyRoute(record) {
+        if (this.warnedV2Postprocess)
+            return;
+        this.warnedV2Postprocess = true;
+        if (typeof console !== "undefined")
+            console.warn(`POSTPROCESS_V2_UNMIGRATED: ${record.message}`);
+    }
+    resolutionGovernor;
+    renderScaleCeiling = 1;
+    unsubscribeDprWatch;
+    /** C-28 FrameStats feeding the governor (intervalMs until lane 11's gpuMs lands). */
+    frameStatsMonitor;
+    /** PRD-02 S12: private graph for `renderProbeFace` (never the main frame graph). */
+    probeGraph;
     constructor(device, options, temporalHistory) {
         this.device = device;
+        if (options.qrFlags)
+            setRendererQrFlags(options.qrFlags, device);
         this.temporalHistory = temporalHistory;
         this.unsubscribeTemporalDeviceLoss = device.onDeviceLost?.(() => this.temporalHistory.dispose());
         this.canvas = options.canvas;
         this.width = options.width ?? inferInitialCanvasDimension(options.canvas, "width");
         this.height = options.height ?? inferInitialCanvasDimension(options.canvas, "height");
         this.clearColor = options.clearColor ?? [0, 0, 0, 1];
+        this.outputClearColor = options.outputClearColor;
+        this.outputOptions = options.output ?? {};
         this.shaderLibrary = options.shaderLibrary;
+        this.host = {
+            device,
+            shaderLibrary: options.shaderLibrary,
+            fusedLdrPostprocessScratch: this.fusedLdrPostprocessScratch,
+            frameIndex: 0
+        };
+        const host = this.host;
+        Object.defineProperty(host, "width", { enumerable: true, get: () => this.width, set: (value) => { this.width = value; } });
+        Object.defineProperty(host, "height", { enumerable: true, get: () => this.height, set: (value) => { this.height = value; } });
+        Object.defineProperty(host, "shadowDepthTarget", { enumerable: true, get: () => this.shadowDepthTarget, set: (value) => { this.shadowDepthTarget = value; } });
+        this.host.post = new RendererPostprocessPipeline(this.host);
+        this.host.shadows = new RendererShadowOrchestrator(this.host);
+        this.resolutionOptions = options.resolution;
+        this.qualityTier = options.qualityTier;
+        this.qualityTierName = options.qualityTierName;
+        if (options.resolution !== undefined && options.resolution.dynamic !== false) {
+            this.resolutionGovernor = new ResolutionGovernor({
+                targetFrameMs: options.resolution.targetFrameMs ?? 16.7,
+                minRenderScale: options.resolution.minRenderScale ?? options.qualityTier?.minRenderScale ?? 0.5,
+                maxRenderScale: 1,
+                devicePixelRatio: typeof globalThis !== "undefined" ? globalThis.devicePixelRatio : undefined,
+                allowSubCssResolution: options.resolution.allowSubCssResolution
+            });
+            // C-28 slot: the default impl is a real FrameStats (gpuMs stays null
+            // until prd11's timer queries land); flags would pick prd11's provider.
+            this.frameStatsMonitor = frameStatsSlot.get({ values: {}, on: () => false })(240);
+        }
+        // §6.9: re-evaluate the canvas pixel ratio when the display DPR changes.
+        this.unsubscribeDprWatch = options.resolution !== undefined && this.canvas
+            ? watchDevicePixelRatio(() => {
+                if (this.disposed)
+                    return;
+                try {
+                    this.resizeToDisplay();
+                }
+                catch { /* keep the current backing size on transient reads */ }
+            })
+            : undefined;
         this.resizeCanvas(this.width, this.height);
     }
-    static async create(options = {}) {
-        const device = await createRenderDevice(options);
-        if (options.requiredFeatures && options.requiredFeatures.length > 0) {
-            assertRendererFeatures(device, options.requiredFeatures);
+    static create(options = {}) {
+        return createRenderer(options);
+    }
+    /** C-28 monitor (PRD-01 Phase 6): lane capture reads cpuSubmitMs percentiles. */
+    get frameStats() {
+        return this.frameStatsMonitor;
+    }
+    /**
+     * PRD-02 S12 (lane-01 half): render `source` into one reflection-probe face.
+     * Signature matches `ReflectionFaceRenderer` (probes/ReflectionProbeSystem.ts)
+     * so it can be passed straight to the probe system:
+     *   new ReflectionProbeSystem(..., (face, target, vp) => renderer.renderProbeFace(scene, face, target, vp))
+     * - `target` may be any size (128/256 px faces): the probe frame is sized to
+     *   it, so RENDER_TARGET_VIEWPORT_MISMATCH does not apply.
+     * - Call it OUTSIDE a frame (before `render`): it opens and closes its own
+     *   device frame and throws FRAME_ALREADY_ACTIVE if one is open (no nesting).
+     * - It uses a private RenderGraph, so the main frame's graph is not cleared.
+     * - Linear output, scene lights + environment, no shadows / post / output
+     *   encode / frame contributors (a probe is radiance input to shading).
+     * Flag-independent; nothing calls it unless a probe system does.
+     */
+    renderProbeFace(source, face, target, viewProjection) {
+        if (target.disposed) {
+            throw new RenderDeviceError("Probe face target is disposed", "RENDER_TARGET_DISPOSED", { face });
+        }
+        const vp = toMat4(viewProjection, "viewProjection", `probe face ${face}`);
+        sceneFromSource(source)?.updateWorldTransforms();
+        const items = collectRenderItems(source, vp).filter((item) => !item.environmentCube);
+        const split = splitForwardItems(items, undefined);
+        const shared = {
+            items: split.opaque,
+            lights: collectRenderLights(source),
+            environmentLighting: collectEnvironmentLighting(source),
+            environmentFog: collectEnvironmentFog(source),
+            cameraViewProjectionMatrix: vp,
+            outputColorSpace: "linear",
+            qualityTier: this.liveQualityTier()?.settings
+        };
+        const graph = (this.probeGraph ??= new RenderGraph());
+        graph.clear();
+        // A probe face has no screen-space transmission input: transmission items
+        // draw with the opaque set; transparent items keep splitForwardItems' sort order.
+        graph.addPass(new ForwardPass({ ...shared, items: [...split.opaque, ...split.transmission], framePass: { name: "prd01.probe.opaque", writes: ["aura.probe.color"] } }));
+        if (split.transparent.length > 0) {
+            graph.addPass(new ForwardPass({ ...shared, items: split.transparent.map((entry) => entry.item), framePass: { name: "prd01.probe.transparent", reads: ["aura.probe.color"], writes: ["aura.probe.color"] } }));
+        }
+        const previous = this.device.getRenderTarget?.() ?? null;
+        this.device.beginFrame(target.width, target.height);
+        try {
+            this.device.setRenderTarget(target);
+            this.device.clear(this.clearColor);
+            graph.execute({ device: this.device, width: target.width, height: target.height });
+        }
+        finally {
+            this.device.setRenderTarget(previous);
+            this.device.endFrame();
+            graph.clear();
         }
-        const shaderLibrary = options.shaderLibrary
-            ?? (await import("./ShaderLibrary.js")).createDefaultShaderLibrary();
-        // Temporal history is an optional runtime subsystem. Keep it behind the
-        // asynchronous renderer factory so non-temporal apps do not place its
-        // shaders, materials, and target owner on their critical download path.
-        const { TemporalHistory } = await import("./TemporalHistory.js");
-        return new Renderer(device, { ...options, shaderLibrary }, new TemporalHistory());
+        return this.device.getDiagnostics();
+    }
+    /** C-28 (#91): run `fn` under the frameStats "post" scope when a monitor exists. */
+    scopePost(fn) {
+        return this.frameStatsMonitor ? this.frameStatsMonitor.scope("post", fn) : fn();
+    }
+    /** C-05: current output configuration (`app.setOutput` / `renderer.output` seam). */
+    get output() {
+        return this.outputOptions;
+    }
+    /** C-05: merge output options; takes effect on the next frame under `A3D_QR_CORE_OUTPUT`. */
+    setOutput(options) {
+        this.outputOptions = { ...this.outputOptions, ...options };
+    }
+    /** C-05: install/replace the juice overlay (pass `null` to clear). */
+    setOutputOverlay(overlay) {
+        this.outputOptions = { ...this.outputOptions, overlay: overlay ?? undefined };
+    }
+    /** What the last OutputPass call actually applied (C-05 diagnostics; null flag-off). */
+    get appliedOutput() {
+        return this.lastAppliedOutput;
     }
     getFeatureReport() {
         return createRendererFeatureReport(this.device);
     }
+    /** C-29 seam (PR 0b): renderer-side device-lifecycle delegates. */
+    onDeviceLost(listener) {
+        return subscribeRendererDeviceLost(this.device, listener);
+    }
+    onDeviceRestored(listener) {
+        return subscribeRendererDeviceRestored(this.device, listener);
+    }
+    isDeviceLost() {
+        return rendererDeviceIsLost(this.device);
+    }
     resize(width, height) {
         this.assertAlive();
         if (width <= 0 || height <= 0 || !Number.isInteger(width) || !Number.isInteger(height)) {
@@ -143,7 +309,14 @@ export class Renderer {
         }
         const cssWidth = options.cssWidth ?? readCanvasCssSize(this.canvas, "width");
         const cssHeight = options.cssHeight ?? readCanvasCssSize(this.canvas, "height");
-        const devicePixelRatio = options.devicePixelRatio ?? globalThis.devicePixelRatio ?? 1;
+        // §6.9: explicit override ?? resolution.pixelRatio ?? min(dpr, tier cap) —
+        // identical to `globalThis.devicePixelRatio` while `resolution`/`tier` are unset.
+        const devicePixelRatio = resolveCanvasPixelRatio({
+            devicePixelRatio: globalThis.devicePixelRatio ?? 1,
+            tier: this.qualityTier ?? this.liveQualityTier()?.settings ?? { maxPixelRatio: Number.POSITIVE_INFINITY },
+            explicit: options.devicePixelRatio,
+            resolution: this.resolutionOptions
+        });
         if (![cssWidth, cssHeight, devicePixelRatio].every(Number.isFinite) || cssWidth <= 0 || cssHeight <= 0 || devicePixelRatio <= 0) {
             throw new RenderDeviceError("Display size and DPR must be finite positive values", "INVALID_DISPLAY_SIZE", {
                 cssWidth,
@@ -159,6 +332,43 @@ export class Renderer {
         }
         return { resized, cssWidth, cssHeight, devicePixelRatio, width, height };
     }
+    /**
+     * §6.9 manual render-scale ceiling (AuraPerformanceQuality.resolutionScale,
+     * request Q-15-1). Caps the scene target only; the canvas backing size is
+     * untouched. `renderScale` reports `min(ceiling, governor)`.
+     */
+    setRenderScaleCeiling(scale) {
+        this.assertAlive();
+        if (!Number.isFinite(scale) || scale <= 0) {
+            throw new RenderDeviceError("Render-scale ceiling must be a positive finite value", "INVALID_RENDER_SCALE", { scale });
+        }
+        this.renderScaleCeiling = Math.min(scale, 1);
+    }
+    get renderScaleCeilingValue() {
+        return this.renderScaleCeiling;
+    }
+    /** Effective render scale: `min(setRenderScaleCeiling, ResolutionGovernor)`. */
+    get renderScale() {
+        return Math.min(this.renderScaleCeiling, this.resolutionGovernor?.scale ?? 1);
+    }
+    /** C-31 `resolution` section values observed by the renderer. */
+    get resolutionReport() {
+        const cssWidth = this.canvas ? readCanvasCssSize(this.canvas, "width") : this.width;
+        return {
+            pixelRatio: cssWidth > 0 ? this.width / cssWidth : 1,
+            renderScale: this.renderScale,
+            renderScaleCeiling: this.renderScaleCeiling,
+            backingWidth: this.width,
+            backingHeight: this.height
+        };
+    }
+    /**
+     * Feeds one frame's timings to the resolution governor (C-28 `gpuMs` wins
+     * over the CPU interval when lane 11's timer queries provide it).
+     */
+    sampleResolutionGovernor(frameMs, gpuMs) {
+        return this.resolutionGovernor?.sample(frameMs, gpuMs) ?? this.renderScale;
+    }
     startAnimationLoop(callback) {
         this.assertAlive();
         this.animationLoop?.stop();
@@ -168,10 +378,42 @@ export class Renderer {
         return loop;
     }
     temporalHistory;
+    /** PRD-03 Phase 4: camera position at the last temporal frame — the >5 m
+     * auto-cut detector. */
+    lastTemporalCameraPosition;
     unsubscribeTemporalDeviceLoss;
-    resetTemporalHistory(_reason = "explicit-reset") { this.temporalHistory.reset(); }
+    /**
+     * PRD-03 §8.6 (flag-on): the v2 S5/S7 stages own the history ping-pong.
+     * When a frame was served by another chain (v2 modules still loading, an
+     * unfusable pass list), the legacy native TAA wrote its own bytes (alpha =
+     * depth, presentation-tuned) into the history target; promoting that seeded
+     * the v2 resolve with garbage. Such frames — and TAA frames on which S5
+     * did not resolve (`markTaaHistoryWritten`) — reset the history instead.
+     */
+    commitTemporalHistory(taa) {
+        const written = consumeTaaHistoryWritten();
+        if (rendererQrFlags(this.device).on("A3D_QR_POST") && (postGraphV2LastOutcome() !== "v2" || (taa && !written))) {
+            this.temporalHistory.reset();
+            return;
+        }
+        this.temporalHistory.commit();
+    }
+    resetTemporalHistory(_reason = "explicit-reset") { this.temporalHistory.reset(); this.lastTemporalCameraPosition = undefined; }
     render(sourceOrInput, camera) {
+        // T0-28: ambient `rendererQrFlags()` readers (Lighting, Background, post…)
+        // see this renderer's flags for the duration of the synchronous frame.
+        return withRendererQrFlags(this.device, () => this.renderFrame(sourceOrInput, camera));
+    }
+    renderFrame(sourceOrInput, camera) {
         this.assertAlive();
+        // §6.9: FrameStats samples every render while a governor exists (resolution opt-in).
+        this.frameStatsMonitor?.begin(typeof performance !== "undefined" ? performance.now() : Date.now());
+        // T0-06: reset the per-frame sync-compile bound for this render.
+        {
+            const flags = rendererQrFlags(this.device);
+            if (qrGeneratedProgramsOn(flags))
+                rendererProgramCache(this.device, flags).beginFrame?.();
+        }
         const { source, camera: inputCamera } = normalizeRendererInput(sourceOrInput, camera);
         sceneFromSource(source)?.updateWorldTransforms();
         const cameraPolicy = collectCameraPolicy(source);
@@ -184,7 +426,7 @@ export class Renderer {
             throw new RenderDeviceError("RenderSource requires an explicit camera but none was supplied or found in the scene.", "CAMERA_REQUIRED");
         }
         let cameraViewProjection = resolvedCamera?.viewProjectionMatrix;
-        const collectedItems = collectRenderItemsWithDiagnostics(source, cameraViewProjection, resolvedCamera?.camera);
+        const collectedItems = collectRenderItemsWithDiagnostics(source, cameraViewProjection, resolvedCamera?.camera, rendererQrFlags().on("A3D_QR_LIGHTING"));
         const collectionDiagnostics = collectedItems.diagnostics;
         let items = collectedItems.items;
         const lights = collectRenderLights(source);
@@ -193,10 +435,26 @@ export class Renderer {
         const environmentFog = collectEnvironmentFog(source);
         const explicitShadowMap = collectForwardShadowMap(source);
         const shadowOptions = collectRendererShadowOptions(source);
+        // C-02/T0-06: sync-path warm — kick generated-program compiles for the
+        // exact draw feature records before the pass runs (bounded per frame).
+        this.warmGeneratedProgramsSync(items, lights, environmentLighting, environmentFog, explicitShadowMap, cameraViewProjection);
         const sourceCameraPosition = collectSourceCameraPosition(source);
         const explicitRenderTarget = collectRenderTarget(source);
         validateExplicitRenderTarget(explicitRenderTarget, this.width, this.height);
         let cameraPosition = sourceCameraPosition ?? resolvedCamera?.cameraPosition;
+        // C-05/T0-07: decide the frame's output route before the hooks exist, so
+        // contributors see the same v2/legacy resource names the graph writes.
+        const route = resolveCoreOutputPostRoute(qrCoreOutputOn(rendererQrFlags(this.device)), collectPostprocess(source));
+        const frameHooks = createRendererFrameHooks({
+            device: this.device,
+            width: this.width,
+            height: this.height,
+            source,
+            camera: toFrameCamera(resolvedCamera, cameraViewProjection, cameraPosition),
+            // PRD 11: the app's live C-27 tier (A3D_QR_TIERS); undefined → high.
+            tier: this.liveQualityTier()?.settings,
+            ...(route.skipped ? { flags: withCoreOutputOff(rendererQrFlags(this.device)) } : {})
+        });
         if (!resolvedCamera && cameraPolicy === "auto-frame") {
             const autoFrame = createAutoFrameCamera(source, items, this.width, this.height);
             if (autoFrame) {
@@ -206,11 +464,24 @@ export class Renderer {
             }
         }
         let postprocess = collectPostprocess(source);
-        if (!postprocess?.temporal || (!postprocess.motionBlur && !postprocess.taa))
+        if (!postprocess?.temporal || (!postprocess.motionBlur && !postprocess.taa)) {
             this.temporalHistory.reset();
+            this.lastTemporalCameraPosition = undefined;
+        }
         const ownedTargets = [];
         const ownedShadowPasses = [];
         this.graph.clear();
+        // C-05 (§8.4): under A3D_QR_CORE_OUTPUT encode happens once, in OutputPass.
+        // A configured legacy post chain still encodes itself (lane 03 migrates it
+        // into post-hdr contributors, Q-03-2/Q-03-3), so the frame takes the legacy
+        // chain and bypasses OutputPass: encode stays single, and the authored
+        // effects (bloom) are kept instead of dropped. The bypass is reported.
+        const qrOutput = route.qrOutput;
+        // §6.2.7: lane passes encode in-shader only on the legacy LDR path.
+        frameHooks.setOutputColorSpace(postprocess || qrOutput ? "linear" : "srgb");
+        this.lastPostSkipped = route.skipped;
+        if (route.skipped)
+            this.warnPostLegacyRoute(route.skipped);
         let postprocessTargetFormat;
         if (postprocess) {
             const format = postprocess.targetFormat ?? defaultPostprocessTargetFormat(this.device, postprocess);
@@ -248,19 +519,52 @@ export class Renderer {
             const forwardTarget = this.ensureForwardColorTarget(format, requiresDepthTexture, sampleCount);
             ownedTargets.push(forwardTarget);
             this.device.setRenderTarget(forwardTarget);
+            frameHooks.setForwardTarget(forwardTarget);
+        }
+        else if (qrOutput) {
+            // C-05: the v2 scene always renders into the HDR target — also on the
+            // no-effects route (§8.4: encode once, in OutputPass). The governor's
+            // renderScale applies to this target only; OutputPass upsamples.
+            const probed = probeHdrTargetFormat(this.device);
+            const format = probed === "rgba8" ? "rgba8" : "rgba16f";
+            const hdrTarget = this.ensureHdrSceneTarget(format, this.outputOptions.backgroundCoverage === true);
+            ownedTargets.push(hdrTarget);
+            this.device.setRenderTarget(hdrTarget);
+            frameHooks.setForwardTarget(hdrTarget);
         }
         this.device.beginFrame(this.width, this.height);
         try {
             this.lastShadowEvidence = null;
-            const rendererShadowMap = explicitShadowMap ?? this.executeRendererShadowMap({
+            items = frameHooks.collect(items);
+            // C-28 (#90): scope the shadow-phase CPU submission for frameStats.
+            // 02-S5: under A3D_QR_LIGHTING casters come from the pre-cull set
+            // (frustum-culled casters rejoin); flag-off keeps the visible items only.
+            const shadowCasterItems = rendererQrFlags().on("A3D_QR_LIGHTING")
+                ? [
+                    ...items,
+                    ...culledCastersReachingView(collectedItems.culledShadowCasters, items, collectedItems.cullingFrustum, shadowSunTravel(lights))
+                ].filter((item) => item.castShadow !== false)
+                : items.filter((item) => item.castShadow !== false);
+            const rendererShadowMap = this.frameStatsMonitor?.scope("shadow", () => explicitShadowMap ?? this.executeRendererShadowMap({
+                shadowOptions,
+                source,
+                items: shadowCasterItems,
+                lights,
+                ownedTargets,
+                ownedShadowPasses,
+                camera: resolvedCamera?.camera,
+                frameCamera: shadowFrameCamera(cameraViewProjection, cameraPosition)
+            })) ?? explicitShadowMap ?? this.executeRendererShadowMap({
                 shadowOptions,
                 source,
-                items: items.filter((item) => item.castShadow !== false),
+                items: shadowCasterItems,
                 lights,
                 ownedTargets,
                 ownedShadowPasses,
-                camera: resolvedCamera?.camera
+                camera: resolvedCamera?.camera,
+                frameCamera: shadowFrameCamera(cameraViewProjection, cameraPosition)
             });
+            frameHooks.addPasses(this.graph, "shadows", items);
             this.lastShadowEvidence = rendererShadowMap ? {
                 lightMatrix: Array.from(rendererShadowMap.lightMatrix),
                 cascades: rendererShadowMap.cascades?.map(c => ({ index: c.index, near: c.near, far: c.far, lightMatrix: Array.from(c.shadowMap.lightMatrix) })) ?? [],
@@ -276,46 +580,162 @@ export class Renderer {
                 }
                 this.device.setRenderTarget(forwardTarget);
             }
+            else if (qrOutput) {
+                // §9.1: clear the HDR target to the linear background color (no ACES
+                // pre-inversion — OutputPass owns the whole encode).
+                this.device.setRenderTarget(ownedTargets[0] ?? null);
+            }
             else {
                 this.device.setRenderTarget(explicitRenderTarget ?? null);
             }
-            this.device.clear(this.clearColor);
+            this.device.clear(qrOutput && !postprocess ? this.outputClearColor ?? this.clearColor : this.clearColor);
             if (environmentBackground) {
                 this.graph.addPass(new EnvironmentBackgroundPass({
                     ...environmentBackground,
-                    outputColorSpace: postprocess ? "linear" : environmentBackground.outputColorSpace,
+                    outputColorSpace: postprocess || qrOutput ? "linear" : environmentBackground.outputColorSpace,
                     inverseViewProjectionMatrix: environmentBackground.inverseViewProjectionMatrix ?? invertMat4(cameraViewProjection ?? identityMat4()),
                     shaderLibrary: this.shaderLibrary
                 }));
+                frameHooks.addPasses(this.graph, "background", items);
+            }
+            // PRD-03 Phase 4 (flag-on): >5 m of camera translation within one frame
+            // is a cut — reprojection would smear everything, so seed fresh history.
+            let temporalPrevVp;
+            let rasterViewProjection = cameraViewProjection;
+            let temporalAutoReset = false;
+            if (postprocess?.temporal && (postprocess.motionBlur || postprocess.taa) && cameraPosition && rendererQrFlags(this.device).on("A3D_QR_POST")) {
+                const prev = this.lastTemporalCameraPosition;
+                if (prev) {
+                    const dx = cameraPosition[0] - prev[0];
+                    const dy = cameraPosition[1] - prev[1];
+                    const dz = cameraPosition[2] - prev[2];
+                    temporalAutoReset = dx * dx + dy * dy + dz * dz > 25;
+                }
+                this.lastTemporalCameraPosition = [cameraPosition[0], cameraPosition[1], cameraPosition[2]];
             }
             if (postprocess?.temporal && (postprocess.motionBlur || postprocess.taa)) {
                 if (postprocess.execution === "cpu-deterministic" || !this.device.presentLdrPostprocess)
                     throw new RenderDeviceError("Renderer temporal effects require native GPU presentation", "TEMPORAL_NATIVE_REQUIRED");
-                const temporal = this.temporalHistory.prepare(this.device, this.width, this.height, items, cameraViewProjection, { ...postprocess.temporal, jitter: Boolean(postprocess.taa) });
+                const temporal = this.temporalHistory.prepare(this.device, this.width, this.height, items, cameraViewProjection, { ...postprocess.temporal, jitter: Boolean(postprocess.taa), ...(temporalAutoReset ? { reset: true } : {}) });
+                temporalPrevVp = temporal.v2?.previous;
+                // PRD-03 §8.6 (flag-on): generated programs project through the
+                // AuraFrame `u_viewProjection`, not the per-item MVP, so the TAA
+                // sub-pixel jitter has to ride the camera matrix too — otherwise the
+                // raster never moves and S5 has nothing to resolve.
+                if (temporal.v2)
+                    rasterViewProjection = temporal.v2.jittered;
                 items = this.temporalHistory.renderItems;
                 postprocess = { ...postprocess, ...(postprocess.motionBlur ? { motionBlur: { ...postprocess.motionBlur, temporal } } : {}), ...(postprocess.taa ? { taa: { ...postprocess.taa, temporal } } : {}) };
                 this.device.setRenderTarget(ownedTargets[0]);
             }
-            this.graph.addPass(new ForwardPass({
-                items,
-                lights,
-                environmentLighting,
-                environmentFog,
-                inputColorResource: environmentBackground ? ENVIRONMENT_BACKGROUND_COLOR_RESOURCE : undefined,
-                shadowMap: rendererShadowMap,
-                cameraPosition,
-                cameraViewMatrix: resolvedCamera?.viewMatrix,
-                cameraViewProjectionMatrix: cameraViewProjection,
-                outputColorSpace: postprocess ? "linear" : "srgb",
-                shaderLibrary: this.shaderLibrary
-            }));
-            this.graph.execute({ device: this.device, width: this.width, height: this.height });
+            if (qrOutput) {
+                // §9.1 v2 frame order: opaque → after-opaque (scene-depth copy,
+                // contributors) → transmission → transmissive → transparent (engine
+                // items + contributor TransparentQueueItems interleaved by sortDepth)
+                // → after-transparent.
+                const hdrTarget = ownedTargets[0] ?? null;
+                const coverage = this.outputOptions.backgroundCoverage === true;
+                const split = splitForwardItems(items, cameraPosition ?? undefined);
+                const shared = {
+                    items: split.opaque,
+                    lights,
+                    environmentLighting,
+                    environmentFog,
+                    inputColorResource: environmentBackground ? ENVIRONMENT_BACKGROUND_COLOR_RESOURCE : undefined,
+                    shadowMap: rendererShadowMap,
+                    cameraPosition,
+                    cameraViewMatrix: resolvedCamera?.viewMatrix,
+                    cameraViewProjectionMatrix: rasterViewProjection,
+                    outputColorSpace: "linear",
+                    shaderLibrary: this.shaderLibrary,
+                    backgroundCoverage: coverage,
+                    qualityTier: this.liveQualityTier()?.settings
+                };
+                // The graph enforces unique names + single-producer writes; per-phase
+                // resources chain the order, and `aura.scene.color` is written once —
+                // by the final interleaved transparent pass.
+                this.graph.addPass(new ForwardPass({ ...shared, framePass: { name: "prd01.opaque", writes: ["aura.scene.color.opaque"] } }));
+                if (hdrTarget?.depthTexture) {
+                    const depthCopy = this.ensureSceneDepthCopy();
+                    frameHooks.setSceneDepthCopy(depthCopy);
+                    this.graph.addPass(new SceneDepthCopyPass(hdrTarget, depthCopy));
+                }
+                frameHooks.addPasses(this.graph, "after-opaque", items);
+                frameHooks.addPasses(this.graph, "transmission", items);
+                let lastColorResource = "aura.scene.color.opaque";
+                if (split.transmission.length > 0) {
+                    lastColorResource = "aura.scene.color.transmission";
+                    this.graph.addPass(new ForwardPass({
+                        ...shared,
+                        items: split.transmission,
+                        framePass: { name: "prd01.transmission", reads: ["aura.scene.color.opaque"], writes: [lastColorResource] }
+                    }));
+                }
+                frameHooks.addTransparentContributorPasses(this.graph, items);
+                const { ctx: contributorCtx, queues } = frameHooks.transparentQueues(items);
+                this.graph.addPass(new InterleavedTransparentPass({ ...shared, items: [] }, split.transparent, queues, contributorCtx, [lastColorResource]));
+                frameHooks.addPasses(this.graph, "after-transparent", items);
+            }
+            else {
+                this.graph.addPass(new ForwardPass({
+                    items,
+                    lights,
+                    environmentLighting,
+                    environmentFog,
+                    inputColorResource: environmentBackground ? ENVIRONMENT_BACKGROUND_COLOR_RESOURCE : undefined,
+                    shadowMap: rendererShadowMap,
+                    cameraPosition,
+                    cameraViewMatrix: resolvedCamera?.viewMatrix,
+                    cameraViewProjectionMatrix: rasterViewProjection,
+                    outputColorSpace: postprocess ? "linear" : "srgb",
+                    shaderLibrary: this.shaderLibrary
+                }));
+                frameHooks.addPasses(this.graph, "after-opaque", items);
+                frameHooks.addPasses(this.graph, "transmission", items);
+                frameHooks.addPasses(this.graph, "transparent", items);
+                frameHooks.addPasses(this.graph, "after-transparent", items);
+            }
+            // C-28 (#90): scope the forward-phase CPU submission for frameStats.
+            if (this.frameStatsMonitor) {
+                this.frameStatsMonitor.scope("forward", () => this.graph.execute({ device: this.device, width: this.width, height: this.height }));
+            }
+            else {
+                this.graph.execute({ device: this.device, width: this.width, height: this.height });
+            }
             if (postprocess) {
                 postprocess = bindRendererSsrProjection(postprocess, cameraViewProjection ?? identityMat4());
-                this.executePostprocess(postprocess, ownedTargets, explicitRenderTarget);
+                const frameCamera = toFrameCamera(resolvedCamera, cameraViewProjection, cameraPosition);
+                postprocess = {
+                    ...postprocess,
+                    cameraFrame: frameCamera && temporalPrevVp ? { ...frameCamera, previousViewProjectionMatrix: temporalPrevVp } : frameCamera,
+                    postFrameContext: {
+                        source,
+                        items,
+                        sceneDepth: {
+                            texture: ownedTargets[0]?.depthTexture ?? null,
+                            available: (ownedTargets[0]?.depthTexture ?? null) !== null,
+                            linearize: {
+                                near: frameCamera?.near ?? 0.1,
+                                far: frameCamera?.far ?? 1000,
+                                orthographic: frameCamera?.projection === "orthographic"
+                            }
+                        }
+                    }
+                };
+                // C-28 (#91): the post-hdr contributors and the postprocess chain report
+                // under the "post" scope (lane 03 owns the chain internals).
+                this.scopePost(() => {
+                    frameHooks.runPhase("post-hdr", items, postprocess !== undefined);
+                    this.executePostprocess(postprocess, ownedTargets, explicitRenderTarget);
+                });
                 if (postprocess.temporal && (postprocess.motionBlur || postprocess.taa))
-                    this.temporalHistory.commit();
+                    this.commitTemporalHistory(Boolean(postprocess.taa));
+            }
+            else if (qrOutput) {
+                this.scopePost(() => frameHooks.runPhase("post-hdr", items, true));
+                this.executeOutputPass(frameHooks, items, ownedTargets[0] ?? null, explicitRenderTarget);
             }
+            frameHooks.runPhase("after-output", items);
         }
         catch (error) {
             this.lastShadowEvidence = null;
@@ -325,6 +745,10 @@ export class Renderer {
         }
         finally {
             this.device.endFrame();
+            if (this.resolutionGovernor && this.frameStatsMonitor) {
+                const frameSample = this.frameStatsMonitor.end();
+                this.resolutionGovernor.sample(frameSample.intervalMs, frameSample.gpuMs);
+            }
             for (const shadowPass of ownedShadowPasses) {
                 shadowPass.dispose();
             }
@@ -347,6 +771,13 @@ export class Renderer {
     }
     async renderAsync(sourceOrInput, camera) {
         this.assertAlive();
+        this.frameStatsMonitor?.begin(typeof performance !== "undefined" ? performance.now() : Date.now());
+        // T0-06: reset the per-frame sync-compile bound for this render.
+        {
+            const flags = rendererQrFlags(this.device);
+            if (qrGeneratedProgramsOn(flags))
+                rendererProgramCache(this.device, flags).beginFrame?.();
+        }
         const { source, camera: inputCamera } = normalizeRendererInput(sourceOrInput, camera);
         sceneFromSource(source)?.updateWorldTransforms();
         const cameraPolicy = collectCameraPolicy(source);
@@ -359,7 +790,7 @@ export class Renderer {
             throw new RenderDeviceError("RenderSource requires an explicit camera but none was supplied or found in the scene.", "CAMERA_REQUIRED");
         }
         let cameraViewProjection = resolvedCamera?.viewProjectionMatrix;
-        const collectedItems = collectRenderItemsWithDiagnostics(source, cameraViewProjection, resolvedCamera?.camera);
+        const collectedItems = collectRenderItemsWithDiagnostics(source, cameraViewProjection, resolvedCamera?.camera, rendererQrFlags().on("A3D_QR_LIGHTING"));
         const collectionDiagnostics = collectedItems.diagnostics;
         let items = collectedItems.items;
         const lights = collectRenderLights(source);
@@ -368,10 +799,26 @@ export class Renderer {
         const environmentFog = collectEnvironmentFog(source);
         const explicitShadowMap = collectForwardShadowMap(source);
         const shadowOptions = collectRendererShadowOptions(source);
+        // C-02 (PRD-01 §403): pre-render warm-then-block compile of the generated
+        // programs this scene needs. Flag-off: nothing (sync path untouched).
+        await this.warmGeneratedPrograms(items, lights, environmentLighting, environmentFog, explicitShadowMap, cameraViewProjection);
         const sourceCameraPosition = collectSourceCameraPosition(source);
         const explicitRenderTarget = collectRenderTarget(source);
         validateExplicitRenderTarget(explicitRenderTarget, this.width, this.height);
         let cameraPosition = sourceCameraPosition ?? resolvedCamera?.cameraPosition;
+        // C-05/T0-07: decide the frame's output route before the hooks exist, so
+        // contributors see the same v2/legacy resource names the graph writes.
+        const route = resolveCoreOutputPostRoute(qrCoreOutputOn(rendererQrFlags(this.device)), collectPostprocess(source));
+        const frameHooks = createRendererFrameHooks({
+            device: this.device,
+            width: this.width,
+            height: this.height,
+            source,
+            camera: toFrameCamera(resolvedCamera, cameraViewProjection, cameraPosition),
+            // PRD 11: the app's live C-27 tier (A3D_QR_TIERS); undefined → high.
+            tier: this.liveQualityTier()?.settings,
+            ...(route.skipped ? { flags: withCoreOutputOff(rendererQrFlags(this.device)) } : {})
+        });
         if (!resolvedCamera && cameraPolicy === "auto-frame") {
             const autoFrame = createAutoFrameCamera(source, items, this.width, this.height);
             if (autoFrame) {
@@ -381,11 +828,24 @@ export class Renderer {
             }
         }
         let postprocess = collectPostprocess(source);
-        if (!postprocess?.temporal || (!postprocess.motionBlur && !postprocess.taa))
+        if (!postprocess?.temporal || (!postprocess.motionBlur && !postprocess.taa)) {
             this.temporalHistory.reset();
+            this.lastTemporalCameraPosition = undefined;
+        }
         const ownedTargets = [];
         const ownedShadowPasses = [];
         this.graph.clear();
+        // C-05 (§8.4): under A3D_QR_CORE_OUTPUT encode happens once, in OutputPass.
+        // A configured legacy post chain still encodes itself (lane 03 migrates it
+        // into post-hdr contributors, Q-03-2/Q-03-3), so the frame takes the legacy
+        // chain and bypasses OutputPass: encode stays single, and the authored
+        // effects (bloom) are kept instead of dropped. The bypass is reported.
+        const qrOutput = route.qrOutput;
+        // §6.2.7: lane passes encode in-shader only on the legacy LDR path.
+        frameHooks.setOutputColorSpace(postprocess || qrOutput ? "linear" : "srgb");
+        this.lastPostSkipped = route.skipped;
+        if (route.skipped)
+            this.warnPostLegacyRoute(route.skipped);
         let postprocessTargetFormat;
         if (postprocess) {
             const format = postprocess.targetFormat ?? defaultPostprocessTargetFormat(this.device, postprocess);
@@ -423,19 +883,52 @@ export class Renderer {
             const forwardTarget = this.ensureForwardColorTarget(format, requiresDepthTexture, sampleCount);
             ownedTargets.push(forwardTarget);
             this.device.setRenderTarget(forwardTarget);
+            frameHooks.setForwardTarget(forwardTarget);
+        }
+        else if (qrOutput) {
+            // C-05: the v2 scene always renders into the HDR target — also on the
+            // no-effects route (§8.4: encode once, in OutputPass). The governor's
+            // renderScale applies to this target only; OutputPass upsamples.
+            const probed = probeHdrTargetFormat(this.device);
+            const format = probed === "rgba8" ? "rgba8" : "rgba16f";
+            const hdrTarget = this.ensureHdrSceneTarget(format, this.outputOptions.backgroundCoverage === true);
+            ownedTargets.push(hdrTarget);
+            this.device.setRenderTarget(hdrTarget);
+            frameHooks.setForwardTarget(hdrTarget);
         }
         this.device.beginFrame(this.width, this.height);
         try {
             this.lastShadowEvidence = null;
-            const rendererShadowMap = explicitShadowMap ?? this.executeRendererShadowMap({
+            items = frameHooks.collect(items);
+            // C-28 (#90): scope the shadow-phase CPU submission for frameStats.
+            // 02-S5: under A3D_QR_LIGHTING casters come from the pre-cull set
+            // (frustum-culled casters rejoin); flag-off keeps the visible items only.
+            const shadowCasterItems = rendererQrFlags().on("A3D_QR_LIGHTING")
+                ? [
+                    ...items,
+                    ...culledCastersReachingView(collectedItems.culledShadowCasters, items, collectedItems.cullingFrustum, shadowSunTravel(lights))
+                ].filter((item) => item.castShadow !== false)
+                : items.filter((item) => item.castShadow !== false);
+            const rendererShadowMap = this.frameStatsMonitor?.scope("shadow", () => explicitShadowMap ?? this.executeRendererShadowMap({
+                shadowOptions,
+                source,
+                items: shadowCasterItems,
+                lights,
+                ownedTargets,
+                ownedShadowPasses,
+                camera: resolvedCamera?.camera,
+                frameCamera: shadowFrameCamera(cameraViewProjection, cameraPosition)
+            })) ?? explicitShadowMap ?? this.executeRendererShadowMap({
                 shadowOptions,
                 source,
-                items: items.filter((item) => item.castShadow !== false),
+                items: shadowCasterItems,
                 lights,
                 ownedTargets,
                 ownedShadowPasses,
-                camera: resolvedCamera?.camera
+                camera: resolvedCamera?.camera,
+                frameCamera: shadowFrameCamera(cameraViewProjection, cameraPosition)
             });
+            frameHooks.addPasses(this.graph, "shadows", items);
             this.lastShadowEvidence = rendererShadowMap ? {
                 lightMatrix: Array.from(rendererShadowMap.lightMatrix),
                 cascades: rendererShadowMap.cascades?.map(c => ({ index: c.index, near: c.near, far: c.far, lightMatrix: Array.from(c.shadowMap.lightMatrix) })) ?? [],
@@ -451,46 +944,162 @@ export class Renderer {
                 }
                 this.device.setRenderTarget(forwardTarget);
             }
+            else if (qrOutput) {
+                // §9.1: clear the HDR target to the linear background color (no ACES
+                // pre-inversion — OutputPass owns the whole encode).
+                this.device.setRenderTarget(ownedTargets[0] ?? null);
+            }
             else {
                 this.device.setRenderTarget(explicitRenderTarget ?? null);
             }
-            this.device.clear(this.clearColor);
+            this.device.clear(qrOutput && !postprocess ? this.outputClearColor ?? this.clearColor : this.clearColor);
             if (environmentBackground) {
                 this.graph.addPass(new EnvironmentBackgroundPass({
                     ...environmentBackground,
-                    outputColorSpace: postprocess ? "linear" : environmentBackground.outputColorSpace,
+                    outputColorSpace: postprocess || qrOutput ? "linear" : environmentBackground.outputColorSpace,
                     inverseViewProjectionMatrix: environmentBackground.inverseViewProjectionMatrix ?? invertMat4(cameraViewProjection ?? identityMat4()),
                     shaderLibrary: this.shaderLibrary
                 }));
+                frameHooks.addPasses(this.graph, "background", items);
+            }
+            // PRD-03 Phase 4 (flag-on): >5 m of camera translation within one frame
+            // is a cut — reprojection would smear everything, so seed fresh history.
+            let temporalPrevVp;
+            let rasterViewProjection = cameraViewProjection;
+            let temporalAutoReset = false;
+            if (postprocess?.temporal && (postprocess.motionBlur || postprocess.taa) && cameraPosition && rendererQrFlags(this.device).on("A3D_QR_POST")) {
+                const prev = this.lastTemporalCameraPosition;
+                if (prev) {
+                    const dx = cameraPosition[0] - prev[0];
+                    const dy = cameraPosition[1] - prev[1];
+                    const dz = cameraPosition[2] - prev[2];
+                    temporalAutoReset = dx * dx + dy * dy + dz * dz > 25;
+                }
+                this.lastTemporalCameraPosition = [cameraPosition[0], cameraPosition[1], cameraPosition[2]];
             }
             if (postprocess?.temporal && (postprocess.motionBlur || postprocess.taa)) {
                 if (postprocess.execution === "cpu-deterministic" || !this.device.presentLdrPostprocess)
                     throw new RenderDeviceError("Renderer temporal effects require native GPU presentation", "TEMPORAL_NATIVE_REQUIRED");
-                const temporal = this.temporalHistory.prepare(this.device, this.width, this.height, items, cameraViewProjection, { ...postprocess.temporal, jitter: Boolean(postprocess.taa) });
+                const temporal = this.temporalHistory.prepare(this.device, this.width, this.height, items, cameraViewProjection, { ...postprocess.temporal, jitter: Boolean(postprocess.taa), ...(temporalAutoReset ? { reset: true } : {}) });
+                temporalPrevVp = temporal.v2?.previous;
+                // PRD-03 §8.6 (flag-on): generated programs project through the
+                // AuraFrame `u_viewProjection`, not the per-item MVP, so the TAA
+                // sub-pixel jitter has to ride the camera matrix too — otherwise the
+                // raster never moves and S5 has nothing to resolve.
+                if (temporal.v2)
+                    rasterViewProjection = temporal.v2.jittered;
                 items = this.temporalHistory.renderItems;
                 postprocess = { ...postprocess, ...(postprocess.motionBlur ? { motionBlur: { ...postprocess.motionBlur, temporal } } : {}), ...(postprocess.taa ? { taa: { ...postprocess.taa, temporal } } : {}) };
                 this.device.setRenderTarget(ownedTargets[0]);
             }
-            this.graph.addPass(new ForwardPass({
-                items,
-                lights,
-                environmentLighting,
-                environmentFog,
-                inputColorResource: environmentBackground ? ENVIRONMENT_BACKGROUND_COLOR_RESOURCE : undefined,
-                shadowMap: rendererShadowMap,
-                cameraPosition,
-                cameraViewMatrix: resolvedCamera?.viewMatrix,
-                cameraViewProjectionMatrix: cameraViewProjection,
-                outputColorSpace: postprocess ? "linear" : "srgb",
-                shaderLibrary: this.shaderLibrary
-            }));
-            this.graph.execute({ device: this.device, width: this.width, height: this.height });
+            if (qrOutput) {
+                // §9.1 v2 frame order: opaque → after-opaque (scene-depth copy,
+                // contributors) → transmission → transmissive → transparent (engine
+                // items + contributor TransparentQueueItems interleaved by sortDepth)
+                // → after-transparent.
+                const hdrTarget = ownedTargets[0] ?? null;
+                const coverage = this.outputOptions.backgroundCoverage === true;
+                const split = splitForwardItems(items, cameraPosition ?? undefined);
+                const shared = {
+                    items: split.opaque,
+                    lights,
+                    environmentLighting,
+                    environmentFog,
+                    inputColorResource: environmentBackground ? ENVIRONMENT_BACKGROUND_COLOR_RESOURCE : undefined,
+                    shadowMap: rendererShadowMap,
+                    cameraPosition,
+                    cameraViewMatrix: resolvedCamera?.viewMatrix,
+                    cameraViewProjectionMatrix: rasterViewProjection,
+                    outputColorSpace: "linear",
+                    shaderLibrary: this.shaderLibrary,
+                    backgroundCoverage: coverage,
+                    qualityTier: this.liveQualityTier()?.settings
+                };
+                // The graph enforces unique names + single-producer writes; per-phase
+                // resources chain the order, and `aura.scene.color` is written once —
+                // by the final interleaved transparent pass.
+                this.graph.addPass(new ForwardPass({ ...shared, framePass: { name: "prd01.opaque", writes: ["aura.scene.color.opaque"] } }));
+                if (hdrTarget?.depthTexture) {
+                    const depthCopy = this.ensureSceneDepthCopy();
+                    frameHooks.setSceneDepthCopy(depthCopy);
+                    this.graph.addPass(new SceneDepthCopyPass(hdrTarget, depthCopy));
+                }
+                frameHooks.addPasses(this.graph, "after-opaque", items);
+                frameHooks.addPasses(this.graph, "transmission", items);
+                let lastColorResource = "aura.scene.color.opaque";
+                if (split.transmission.length > 0) {
+                    lastColorResource = "aura.scene.color.transmission";
+                    this.graph.addPass(new ForwardPass({
+                        ...shared,
+                        items: split.transmission,
+                        framePass: { name: "prd01.transmission", reads: ["aura.scene.color.opaque"], writes: [lastColorResource] }
+                    }));
+                }
+                frameHooks.addTransparentContributorPasses(this.graph, items);
+                const { ctx: contributorCtx, queues } = frameHooks.transparentQueues(items);
+                this.graph.addPass(new InterleavedTransparentPass({ ...shared, items: [] }, split.transparent, queues, contributorCtx, [lastColorResource]));
+                frameHooks.addPasses(this.graph, "after-transparent", items);
+            }
+            else {
+                this.graph.addPass(new ForwardPass({
+                    items,
+                    lights,
+                    environmentLighting,
+                    environmentFog,
+                    inputColorResource: environmentBackground ? ENVIRONMENT_BACKGROUND_COLOR_RESOURCE : undefined,
+                    shadowMap: rendererShadowMap,
+                    cameraPosition,
+                    cameraViewMatrix: resolvedCamera?.viewMatrix,
+                    cameraViewProjectionMatrix: rasterViewProjection,
+                    outputColorSpace: postprocess ? "linear" : "srgb",
+                    shaderLibrary: this.shaderLibrary
+                }));
+                frameHooks.addPasses(this.graph, "after-opaque", items);
+                frameHooks.addPasses(this.graph, "transmission", items);
+                frameHooks.addPasses(this.graph, "transparent", items);
+                frameHooks.addPasses(this.graph, "after-transparent", items);
+            }
+            // C-28 (#90): scope the forward-phase CPU submission for frameStats.
+            if (this.frameStatsMonitor) {
+                this.frameStatsMonitor.scope("forward", () => this.graph.execute({ device: this.device, width: this.width, height: this.height }));
+            }
+            else {
+                this.graph.execute({ device: this.device, width: this.width, height: this.height });
+            }
             if (postprocess) {
                 postprocess = bindRendererSsrProjection(postprocess, cameraViewProjection ?? identityMat4());
-                await this.executePostprocessAsync(postprocess, ownedTargets, explicitRenderTarget);
+                const frameCamera = toFrameCamera(resolvedCamera, cameraViewProjection, cameraPosition);
+                postprocess = {
+                    ...postprocess,
+                    cameraFrame: frameCamera && temporalPrevVp ? { ...frameCamera, previousViewProjectionMatrix: temporalPrevVp } : frameCamera,
+                    postFrameContext: {
+                        source,
+                        items,
+                        sceneDepth: {
+                            texture: ownedTargets[0]?.depthTexture ?? null,
+                            available: (ownedTargets[0]?.depthTexture ?? null) !== null,
+                            linearize: {
+                                near: frameCamera?.near ?? 0.1,
+                                far: frameCamera?.far ?? 1000,
+                                orthographic: frameCamera?.projection === "orthographic"
+                            }
+                        }
+                    }
+                };
+                // C-28 (#91): "post" scope. FrameStats.scope is synchronous, so on the
+                // async path it times the CPU submission up to the first await.
+                await this.scopePost(async () => {
+                    await frameHooks.runPhaseAsync("post-hdr", items, postprocess !== undefined);
+                    await this.executePostprocessAsync(postprocess, ownedTargets, explicitRenderTarget);
+                });
                 if (postprocess.temporal && (postprocess.motionBlur || postprocess.taa))
-                    this.temporalHistory.commit();
+                    this.commitTemporalHistory(Boolean(postprocess.taa));
+            }
+            else if (qrOutput) {
+                await this.scopePost(() => frameHooks.runPhaseAsync("post-hdr", items, true));
+                this.executeOutputPass(frameHooks, items, ownedTargets[0] ?? null, explicitRenderTarget);
             }
+            await frameHooks.runPhaseAsync("after-output", items);
         }
         catch (error) {
             this.lastShadowEvidence = null;
@@ -500,6 +1109,10 @@ export class Renderer {
         }
         finally {
             this.device.endFrame();
+            if (this.resolutionGovernor && this.frameStatsMonitor) {
+                const frameSample = this.frameStatsMonitor.end();
+                this.resolutionGovernor.sample(frameSample.intervalMs, frameSample.gpuMs);
+            }
             for (const shadowPass of ownedShadowPasses) {
                 shadowPass.dispose();
             }
@@ -520,6 +1133,89 @@ export class Renderer {
             rendererDepthAvailable: Boolean(postprocess && postprocessRequiresDepthTexture(postprocess) && this.device.info.capabilities?.includes("depth-textures"))
         }));
     }
+    /**
+     * C-02 (PRD-01 §8.2/§403): warm-then-block. Under `A3D_QR_CORE_GENERATOR`
+     * (default-on under `A3D_QR_CORE`), precompiles the generated programs for
+     * every allow-listed material in the frame — at the current tier and the
+     * next-lower one — before the first draw, so the pass never async-skips in
+     * steady state. Flag-off and non-generated materials are no-ops.
+     */
+    /**
+     * Shared T0-06 warm input: the exact draw feature records the frame's
+     * generated-program materials need (lights/shadow/environment axes at the
+     * current tier). Returns `materials: []` early when nothing generated.
+     */
+    collectWarmupInput(items, lights, environmentLighting, environmentFog, shadowMap, cameraViewProjection, flags, tier) {
+        const ctx = { flags, tier: QUALITY_TIERS[tier] };
+        // T0-05: one record per (material revision, selected feature bits) — the
+        // draw key carries `ShaderFeature.select` bits per item, so the warm list
+        // must too or warmed keys never match draw keys.
+        const records = new Map();
+        const route = { core: qrCoreGeneratorOn(flags), lobes: qrMaterialsLobeProgramsOn(flags) };
+        for (const item of items) {
+            const m = item.material instanceof MaterialInstance ? item.material.baseMaterial : item.material;
+            if (!m || !materialRoutesToGeneratedProgram(m, route, ctx))
+                continue;
+            const mf = m.programFeatures(ctx);
+            const selected = selectShaderFeatureBits({ item, pass: "forward", tier: ctx.tier, flags });
+            // E3 stage-2b: same probe-availability gate ForwardPass applies, so
+            // warmed keys match draw keys for the `prd02.ibl` bit.
+            if (selected[PRD02_IBL_FEATURE] !== undefined && !prd02IblEnvironmentAvailable(environmentLighting, item)) {
+                delete selected[PRD02_IBL_FEATURE];
+            }
+            // #867 (games): same geometry-driven feature mask ForwardPass applies.
+            const attrs = item.geometry.vertexBuffer.format.attributes;
+            const has = (name) => attrs.some((a) => a.semantic === name || a.shaderName === name);
+            const record = featuresForGeometry({ ...mf, features: { ...mf.features, ...selected } }, has);
+            const geometryMask = ["a_uv", "a_uv1", "a_color", "a_joints", "a_weights", "a_joints1", "a_weights1"].map((n) => (has(n) ? 1 : 0)).join("");
+            const key = `${m.shaderKey}:${m.getRevision()}:${geometryMask}:${JSON.stringify(Object.entries(record.features).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))}`;
+            if (!records.has(key))
+                records.set(key, record);
+        }
+        if (records.size === 0)
+            return { materials: [] };
+        const clustered = resolveForwardClusteredLighting(lights, this.width, this.height, cameraViewProjection);
+        const axes = forwardPassFeatureAxes({ lights, shadowMap, environmentLighting, environmentFog }, clustered !== null);
+        clustered?.dispose();
+        return {
+            materials: [...records.values()],
+            lights: [axes.lights],
+            shadows: axes.shadows ? [axes.shadows] : [],
+            environments: [axes.environment]
+        };
+    }
+    async warmGeneratedPrograms(items, lights, environmentLighting, environmentFog, shadowMap, cameraViewProjection) {
+        const flags = rendererQrFlags(this.device);
+        if (!qrGeneratedProgramsOn(flags))
+            return;
+        const tier = this.qualityTierName ?? prd11LiveQualityTier(flags)?.tier ?? "high";
+        const cache = rendererProgramCache(this.device, flags);
+        const input = this.collectWarmupInput(items, lights, environmentLighting, environmentFog, shadowMap, cameraViewProjection, flags, tier);
+        if (input.materials.length > 0) {
+            const warmup = (this.programWarmup ??= new ProgramWarmup(cache));
+            await warmup.warm(input, tier);
+        }
+        // T0-06: the ready barrier for `programsCompiledSinceReady` — compiles
+        // completing after the first warm count as steady-state leaks.
+        cache.markReady?.();
+    }
+    /**
+     * T0-06: the sync `render` half of warm-then-block. Kicks `acquire` for the
+     * exact draw feature records — async-compile devices start pending entries
+     * (`precompile`/`app.ready` settle them); sync-compile devices compile under
+     * the per-frame bound and converge over the next frames.
+     */
+    warmGeneratedProgramsSync(items, lights, environmentLighting, environmentFog, shadowMap, cameraViewProjection) {
+        const flags = rendererQrFlags(this.device);
+        if (!qrGeneratedProgramsOn(flags))
+            return;
+        const tier = this.qualityTierName ?? prd11LiveQualityTier(flags)?.tier ?? "high";
+        const cache = rendererProgramCache(this.device, flags);
+        const input = this.collectWarmupInput(items, lights, environmentLighting, environmentFog, shadowMap, cameraViewProjection, flags, tier);
+        for (const features of collectWarmupFeatures(input, tier))
+            cache.acquire(features);
+        cache.markReady?.();
+    }
     renderScene(scene, camera) {
         return this.render(scene, camera);
     }
@@ -555,14 +1251,83 @@ export class Renderer {
         this.shadowDepthTarget = null;
         this.forwardColorTarget?.target.dispose();
         this.forwardColorTarget = null;
+        this.hdrSceneTarget?.target.dispose();
+        this.hdrSceneTarget = null;
+        this.sceneDepthCopyTarget?.dispose();
+        this.sceneDepthCopyTarget = null;
         this.unsubscribeTemporalDeviceLoss?.();
+        this.unsubscribeDprWatch?.();
         this.temporalHistory.dispose();
         this.device.dispose();
         this.disposed = true;
     }
     /** True for renderer-lifetime targets that must survive end-of-frame disposal. */
     isReusedTarget(target) {
-        return target === this.forwardColorTarget?.target || target === this.shadowDepthTarget;
+        return target === this.forwardColorTarget?.target || target === this.shadowDepthTarget || target === this.hdrSceneTarget?.target || target === this.sceneDepthCopyTarget;
+    }
+    /**
+     * C-05 HDR scene target under `A3D_QR_CORE_OUTPUT` — always a sampleable
+     * depth texture (sceneDepth / after-opaque copy), renderScale-sized, MSAA 4x,
+     * plus the BACKGROUND_COVERAGE rgba8 attachment when the option is on.
+     */
+    ensureHdrSceneTarget(format, coverage) {
+        const scale = Math.min(Math.max(this.renderScale, 0.01), 1);
+        const width = Math.max(1, Math.round(this.width * scale));
+        const height = Math.max(1, Math.round(this.height * scale));
+        // C-36: WebGL2 does not support multisample MRT — coverage forces a
+        // non-MSAA target and is declared via `hdr-msaa-mrt-unsupported`.
+        const sampleCount = coverage ? 1 : 4;
+        const key = `${width}x${height}:${format}:depth-texture:${sampleCount}:${coverage ? "cov" : "std"}`;
+        const cached = this.hdrSceneTarget;
+        if (cached && cached.key === key && !cached.target.disposed)
+            return cached.target;
+        cached?.target.dispose();
+        const target = this.device.createRenderTarget({
+            width,
+            height,
+            label: "renderer-hdr-scene",
+            format,
+            ...(coverage ? { colorAttachments: [{ format }, { format: "rgba8" }] } : {}),
+            depth: "texture",
+            sampleCount
+        });
+        this.hdrMsaaMrtDegraded = coverage;
+        this.hdrSceneTarget = { target, key };
+        return target;
+    }
+    ensureSceneDepthCopy() {
+        this.sceneDepthCopyTarget = ensureSceneDepthCopyTarget(this.device, this.sceneDepthCopyTarget, this.width, this.height);
+        return this.sceneDepthCopyTarget;
+    }
+    /**
+     * C-05 OutputPass invocation (§8.4 step "output"): `u_exposure` =
+     * `output.exposure × blackboard["prd03.exposure"]` (upstream defaults to 1
+     * until lane 03 publishes it — Q-03-1).
+     */
+    executeOutputPass(frameHooks, _items, hdrTarget, explicitRenderTarget) {
+        if (!hdrTarget)
+            return;
+        const o = this.outputOptions;
+        const upstream = frameHooks.blackboardValue(PRD03_EXPOSURE);
+        const appliedExposure = (o.exposure ?? 1) * (typeof upstream === "number" && Number.isFinite(upstream) ? upstream : 1);
+        const format = probeHdrTargetFormat(this.device);
+        const targetFormat = format === "rgba8" ? "rgba8" : "rgba16f";
+        const coverage = o.backgroundCoverage === true;
+        this.device.setRenderTarget(explicitRenderTarget ?? null);
+        rendererOutputPass(this.device).execute(hdrTarget, coverage ? hdrTarget : null, {
+            toneMapping: o.toneMapping ?? DEFAULT_TONE_MAPPING,
+            exposure: appliedExposure,
+            dithering: o.dithering ?? DEFAULT_OUTPUT_DITHERING,
+            backgroundCoverage: coverage,
+            overlay: o.overlay
+        }, explicitRenderTarget ?? "canvas");
+        this.lastAppliedOutput = {
+            toneMapping: o.toneMapping ?? DEFAULT_TONE_MAPPING,
+            exposure: { applied: appliedExposure, source: upstream !== undefined ? "grade" : "output" },
+            dithering: o.dithering ?? DEFAULT_OUTPUT_DITHERING,
+            targetFormat,
+            degraded: targetFormat === "rgba8" ? "rgba8-no-float-target" : this.hdrMsaaMrtDegraded ? "hdr-msaa-mrt-unsupported" : undefined
+        };
     }
     /** Allocates the shared forward-color target once per distinct configuration. */
     ensureForwardColorTarget(format, requiresDepthTexture, sampleCount) {
@@ -582,21 +1347,9 @@ export class Renderer {
         this.forwardColorTarget = { target, key };
         return target;
     }
-    /** Allocates the shared shadow depth target once, reallocating only when the size changes. */
-    ensureShadowDepthTarget(size) {
-        const existing = this.shadowDepthTarget;
-        if (existing && !existing.disposed && existing.width === size && existing.height === size)
-            return existing;
-        existing?.dispose();
-        const target = this.device.createRenderTarget({
-            width: size,
-            height: size,
-            label: "renderer-shadow-depth-color",
-            format: "rgba8",
-            depth: this.device.info.capabilities?.includes("depth-textures") ? "texture" : true
-        });
-        this.shadowDepthTarget = target;
-        return target;
+    /** PRD 11: this device's app-bound live C-27 tier (A3D_QR_TIERS on), else undefined. */
+    liveQualityTier() {
+        return prd11LiveQualityTier(rendererQrFlags(this.device));
     }
     assertAlive() {
         if (this.disposed || this.device.disposed) {
@@ -614,584 +1367,13 @@ export class Renderer {
         }
     }
     executePostprocess(postprocess, ownedTargets, outputTarget) {
-        const forwardTarget = ownedTargets[0];
-        let current = forwardTarget;
-        if (!current) {
-            throw new RenderDeviceError("Renderer postprocess missing forward render target", "POSTPROCESS_TARGET_MISSING");
-        }
-        const passes = createRendererPostprocessPasses(postprocess);
-        if (passes.length === 0) {
-            if (outputTarget) {
-                this.device.setRenderTarget(current);
-                writePostProcessPixels(this.device, current, outputTarget, this.device.readPixels(0, 0, current.width, current.height));
-            }
-            else {
-                this.device.presentRenderTarget?.(current);
-            }
-            return;
-        }
-        if (this.executeFusedLdrPostprocess(current, passes, outputTarget, postprocess.execution === "cpu-deterministic"))
-            return;
-        for (let index = 0; index < passes.length; index += 1) {
-            const pass = passes[index];
-            const nextPass = passes[index + 1];
-            if (pass.name === "bloom" && isHdrRenderTarget(current)) {
-                if (nextPass?.name !== "tone-mapping") {
-                    throw new RenderDeviceError("Renderer HDR bloom requires tone mapping immediately after the float bloom pass.", "HDR_BLOOM_TONEMAPPING_REQUIRED", {
-                        source: current.label
-                    });
-                }
-                const isCombinedLast = index + 1 === passes.length - 1;
-                const target = isCombinedLast ? outputTarget : this.device.createRenderTarget({
-                    width: this.width,
-                    height: this.height,
-                    label: "renderer-postprocess-tone-mapping",
-                    format: "rgba8",
-                    depth: false
-                });
-                if (target)
-                    ownedTargets.push(target);
-                this.device.setRenderTarget(current);
-                const bloomed = bloomFloatPixels(this.device.readFloatPixels(0, 0, current.width, current.height), current.width, current.height, pass.options);
-                const mapped = toneMapFloatPixels(bloomed.pixels, current.width, current.height, {
-                    outputColorSpace: "srgb",
-                    ...nextPass.options
-                });
-                writePostProcessPixels(this.device, current, target, mapped.pixels);
-                if (target)
-                    current = target;
-                index += 1;
-                continue;
-            }
-            const isLast = index === passes.length - 1;
-            const target = isLast ? outputTarget : this.device.createRenderTarget({
-                width: this.width,
-                height: this.height,
-                label: `renderer-postprocess-${pass.name}`,
-                format: "rgba8",
-                depth: false
-            });
-            if (target)
-                ownedTargets.push(target);
-            if (pass.name === "tone-mapping") {
-                new ToneMappingPass({
-                    source: current,
-                    target,
-                    outputColorSpace: "srgb",
-                    ...pass.options
-                }).execute({ device: this.device, width: this.width, height: this.height });
-            }
-            else if (pass.name === "bloom") {
-                new BloomPass({
-                    source: current,
-                    target,
-                    ...pass.options
-                }).execute({ device: this.device, width: this.width, height: this.height });
-            }
-            else if (pass.name === "fxaa") {
-                new FXAAPass({
-                    source: current,
-                    target,
-                    ...pass.options
-                }).execute({ device: this.device, width: this.width, height: this.height });
-            }
-            else {
-                this.executePixelPostprocessPass(pass, current, target, forwardTarget);
-            }
-            if (target)
-                current = target;
-        }
-    }
-    executeFusedLdrPostprocess(current, passes, outputTarget, forceCpuDeterministic = false) {
-        const nativeHdrBloom = isHdrRenderTarget(current) && passes[0]?.name === "bloom" && passes[1]?.name === "tone-mapping";
-        if (nativeHdrBloom && (forceCpuDeterministic || !this.device.presentLdrPostprocess))
-            return false;
-        if (!canFuseLdrPostprocess(current, passes))
-            return false;
-        if (!forceCpuDeterministic && !this.device.presentLdrPostprocess && passes.some((pass) => pass.name === "depth-of-field" || pass.name === "motion-blur" || pass.name === "ssao" || pass.name === "ssr" || pass.name === "taa"))
-            return false;
-        // A caller that supplies its own `depth` array for depth-of-field/SSAO/SSR gets a plain
-        // depth renderbuffer, because `postprocessRequiresDepthTexture` only requests a
-        // sampleable depth texture when the renderer has to generate the depth itself. The
-        // backend's fused path samples `depthTextureHandle` regardless and used to throw
-        // `WEBGL_LDR_POSTPROCESS_DEPTH_REQUIRED`, failing the whole render rather than falling
-        // back. Declining fusion here routes those passes through the per-pass CPU path, which
-        // consumes the caller's depth directly and is the behaviour the options already imply.
-        if (!forceCpuDeterministic && !current.depthTexture && passes.some((pass) => pass.name === "depth-of-field" || pass.name === "ssao" || pass.name === "ssr"))
-            return false;
-        if (!forceCpuDeterministic && this.device.presentLdrPostprocess) {
-            this.device.presentLdrPostprocess(current, {
-                passes: passes.map((pass) => ({
-                    name: pass.name,
-                    options: pass.options
-                })),
-                ...(outputTarget ? { outputTarget } : {}),
-                toneMappingDefaults: { outputColorSpace: "srgb" }
-            });
-            return true;
-        }
-        this.device.setRenderTarget(current);
-        const pixels = fusedLdrPostprocessPixels(this.device.readPixels(0, 0, current.width, current.height), current.width, current.height, passes, {
-            mutateInput: true,
-            scratch: this.fusedLdrPostprocessScratch,
-            toneMappingDefaults: { outputColorSpace: "srgb" }
-        });
-        writePostProcessPixels(this.device, current, outputTarget, pixels);
-        return true;
+        return this.host.post.executePostprocess(postprocess, ownedTargets, outputTarget);
     }
     async executePostprocessAsync(postprocess, ownedTargets, outputTarget) {
-        const forwardTarget = ownedTargets[0];
-        let current = forwardTarget;
-        if (!current) {
-            throw new RenderDeviceError("Renderer postprocess missing forward render target", "POSTPROCESS_TARGET_MISSING");
-        }
-        const passes = createRendererPostprocessPasses(postprocess);
-        if (passes.length === 0) {
-            if (outputTarget) {
-                this.device.setRenderTarget(current);
-                writePostProcessPixels(this.device, current, outputTarget, await this.readRenderTargetPixelsAsync(current));
-            }
-            else {
-                this.device.presentRenderTarget?.(current);
-            }
-            return;
-        }
-        if (await this.executeFusedLdrPostprocessAsync(current, passes, outputTarget, postprocess.execution === "cpu-deterministic"))
-            return;
-        for (let index = 0; index < passes.length; index += 1) {
-            const pass = passes[index];
-            const nextPass = passes[index + 1];
-            if (pass.name === "bloom" && isHdrRenderTarget(current)) {
-                if (nextPass?.name !== "tone-mapping") {
-                    throw new RenderDeviceError("Renderer HDR bloom requires tone mapping immediately after the float bloom pass.", "HDR_BLOOM_TONEMAPPING_REQUIRED", {
-                        source: current.label
-                    });
-                }
-                const isCombinedLast = index + 1 === passes.length - 1;
-                const target = isCombinedLast ? outputTarget : this.device.createRenderTarget({
-                    width: this.width,
-                    height: this.height,
-                    label: "renderer-postprocess-tone-mapping",
-                    format: "rgba8",
-                    depth: false
-                });
-                if (target)
-                    ownedTargets.push(target);
-                const bloomed = bloomFloatPixels(await this.readRenderTargetFloatPixelsAsync(current), current.width, current.height, pass.options);
-                const mapped = toneMapFloatPixels(bloomed.pixels, current.width, current.height, {
-                    outputColorSpace: "srgb",
-                    ...nextPass.options
-                });
-                writePostProcessPixels(this.device, current, target, mapped.pixels);
-                if (target)
-                    current = target;
-                index += 1;
-                continue;
-            }
-            const isLast = index === passes.length - 1;
-            const target = isLast ? outputTarget : this.device.createRenderTarget({
-                width: this.width,
-                height: this.height,
-                label: `renderer-postprocess-${pass.name}`,
-                format: "rgba8",
-                depth: false
-            });
-            if (target)
-                ownedTargets.push(target);
-            if (pass.name === "tone-mapping") {
-                const mapped = isHdrRenderTarget(current)
-                    ? toneMapFloatPixels(await this.readRenderTargetFloatPixelsAsync(current), current.width, current.height, {
-                        outputColorSpace: "srgb",
-                        ...pass.options
-                    })
-                    : toneMapPixels(await this.readRenderTargetPixelsAsync(current), current.width, current.height, {
-                        outputColorSpace: "srgb",
-                        ...pass.options
-                    });
-                writePostProcessPixels(this.device, current, target, mapped.pixels);
-            }
-            else if (pass.name === "bloom") {
-                const bloomed = bloomPixels(await this.readRenderTargetPixelsAsync(current), current.width, current.height, pass.options);
-                writePostProcessPixels(this.device, current, target, bloomed.pixels);
-            }
-            else if (pass.name === "fxaa") {
-                const smoothed = fxaaPixels(await this.readRenderTargetPixelsAsync(current), current.width, current.height, pass.options);
-                writePostProcessPixels(this.device, current, target, smoothed.pixels);
-            }
-            else {
-                await this.executePixelPostprocessPassAsync(pass, current, target, forwardTarget);
-            }
-            if (target)
-                current = target;
-        }
-    }
-    async executeFusedLdrPostprocessAsync(current, passes, outputTarget, forceCpuDeterministic = false) {
-        const nativeHdrBloom = isHdrRenderTarget(current) && passes[0]?.name === "bloom" && passes[1]?.name === "tone-mapping";
-        if (nativeHdrBloom && (forceCpuDeterministic || !this.device.presentLdrPostprocess))
-            return false;
-        if (!canFuseLdrPostprocess(current, passes))
-            return false;
-        if (!forceCpuDeterministic && !this.device.presentLdrPostprocess && passes.some((pass) => pass.name === "depth-of-field" || pass.name === "motion-blur" || pass.name === "ssao" || pass.name === "ssr" || pass.name === "taa"))
-            return false;
-        // A caller that supplies its own `depth` array for depth-of-field/SSAO/SSR gets a plain
-        // depth renderbuffer, because `postprocessRequiresDepthTexture` only requests a
-        // sampleable depth texture when the renderer has to generate the depth itself. The
-        // backend's fused path samples `depthTextureHandle` regardless and used to throw
-        // `WEBGL_LDR_POSTPROCESS_DEPTH_REQUIRED`, failing the whole render rather than falling
-        // back. Declining fusion here routes those passes through the per-pass CPU path, which
-        // consumes the caller's depth directly and is the behaviour the options already imply.
-        if (!forceCpuDeterministic && !current.depthTexture && passes.some((pass) => pass.name === "depth-of-field" || pass.name === "ssao" || pass.name === "ssr"))
-            return false;
-        if (!forceCpuDeterministic && this.device.presentLdrPostprocess) {
-            this.device.presentLdrPostprocess(current, {
-                passes: passes.map((pass) => ({
-                    name: pass.name,
-                    options: pass.options
-                })),
-                ...(outputTarget ? { outputTarget } : {}),
-                toneMappingDefaults: { outputColorSpace: "srgb" }
-            });
-            return true;
-        }
-        const pixels = fusedLdrPostprocessPixels(await this.readRenderTargetPixelsAsync(current), current.width, current.height, passes, {
-            mutateInput: true,
-            scratch: this.fusedLdrPostprocessScratch,
-            toneMappingDefaults: { outputColorSpace: "srgb" }
-        });
-        writePostProcessPixels(this.device, current, outputTarget, pixels);
-        return true;
-    }
-    executePixelPostprocessPass(pass, source, target, forwardTarget) {
-        this.device.setRenderTarget(source);
-        const input = this.device.readPixels(0, 0, source.width, source.height);
-        const rendererDepth = isDepthPostprocessPass(pass.name) && !postprocessPassHasDepth(pass.options)
-            ? this.readRendererOwnedDepthTexture(forwardTarget)
-            : undefined;
-        const result = pass.name === "color-grade"
-            ? colorGradePixels(input, source.width, source.height, pass.options).pixels
-            : pass.name === "chromatic-aberration"
-                ? chromaticAberrationPixels(input, source.width, source.height, pass.options).pixels
-                : pass.name === "film-grain"
-                    ? filmGrainPixels(input, source.width, source.height, pass.options).pixels
-                    : pass.name === "depth-of-field"
-                        ? depthOfFieldPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                        : pass.name === "volumetric-light"
-                            ? volumetricLightPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                            : pass.name === "motion-blur"
-                                ? motionBlurPixels(input, source.width, source.height, pass.options).pixels
-                                : pass.name === "contact-shadow"
-                                    ? contactShadowPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                                    : pass.name === "ssao"
-                                        ? ssaoPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                                        : pass.name === "ssr"
-                                            ? ssrPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                                            : pass.name === "taa"
-                                                ? taaPixels(input, source.width, source.height, pass.options).pixels
-                                                : pass.name === "outline"
-                                                    ? outlinePixels(input, source.width, source.height, pass.options).pixels
-                                                    : undefined;
-        if (!result) {
-            throw new RenderDeviceError("Renderer postprocess pass is outside the supported renderer pass catalog", "POSTPROCESS_PASS_UNKNOWN", {
-                pass: pass.name
-            });
-        }
-        writePostProcessPixels(this.device, source, target, result);
-    }
-    async executePixelPostprocessPassAsync(pass, source, target, forwardTarget) {
-        const input = await this.readRenderTargetPixelsAsync(source);
-        const rendererDepth = isDepthPostprocessPass(pass.name) && !postprocessPassHasDepth(pass.options)
-            ? this.readRendererOwnedDepthTexture(forwardTarget)
-            : undefined;
-        const result = pass.name === "color-grade"
-            ? colorGradePixels(input, source.width, source.height, pass.options).pixels
-            : pass.name === "chromatic-aberration"
-                ? chromaticAberrationPixels(input, source.width, source.height, pass.options).pixels
-                : pass.name === "film-grain"
-                    ? filmGrainPixels(input, source.width, source.height, pass.options).pixels
-                    : pass.name === "depth-of-field"
-                        ? depthOfFieldPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                        : pass.name === "volumetric-light"
-                            ? volumetricLightPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                            : pass.name === "motion-blur"
-                                ? motionBlurPixels(input, source.width, source.height, pass.options).pixels
-                                : pass.name === "contact-shadow"
-                                    ? contactShadowPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                                    : pass.name === "ssao"
-                                        ? ssaoPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                                        : pass.name === "ssr"
-                                            ? ssrPixels(input, source.width, source.height, withRendererDepth(pass.options, rendererDepth)).pixels
-                                            : pass.name === "taa"
-                                                ? taaPixels(input, source.width, source.height, pass.options).pixels
-                                                : pass.name === "outline"
-                                                    ? outlinePixels(input, source.width, source.height, pass.options).pixels
-                                                    : undefined;
-        if (!result) {
-            throw new RenderDeviceError("Renderer postprocess pass is outside the supported renderer pass catalog", "POSTPROCESS_PASS_UNKNOWN", {
-                pass: pass.name
-            });
-        }
-        writePostProcessPixels(this.device, source, target, result);
-    }
-    async readRenderTargetPixelsAsync(target) {
-        this.device.setRenderTarget(target);
-        if (this.device.readPixelsAsync && target.colorTexture.format === "rgba8") {
-            return this.device.readPixelsAsync(0, 0, target.width, target.height);
-        }
-        return this.device.readPixels(0, 0, target.width, target.height);
-    }
-    async readRenderTargetFloatPixelsAsync(target) {
-        this.device.setRenderTarget(target);
-        if (this.device.readFloatPixelsAsync && isHdrRenderTarget(target)) {
-            return this.device.readFloatPixelsAsync(0, 0, target.width, target.height);
-        }
-        return this.device.readFloatPixels(0, 0, target.width, target.height);
-    }
-    readRendererOwnedDepthTexture(forwardTarget) {
-        if (!forwardTarget.depthTexture) {
-            throw new RenderDeviceError("Renderer-owned depth postprocess requires the forward target to expose a depth texture.", "POSTPROCESS_DEPTH_TARGET_MISSING", {
-                renderTarget: forwardTarget.label
-            });
-        }
-        if (!this.device.readDepthPixels) {
-            throw new RenderDeviceError("Renderer-owned depth postprocess requires backend depth readback.", "DEPTH_READBACK_UNSUPPORTED", {
-                backend: this.device.kind
-            });
-        }
-        this.device.setRenderTarget(forwardTarget);
-        return createDepthTextureBinding({
-            label: forwardTarget.depthTexture.label,
-            width: forwardTarget.width,
-            height: forwardTarget.height,
-            data: this.device.readDepthPixels(0, 0, forwardTarget.width, forwardTarget.height)
-        });
+        return this.host.post.executePostprocessAsync(postprocess, ownedTargets, outputTarget);
     }
     executeRendererShadowMap(options) {
-        if (!options.shadowOptions || options.shadowOptions.enabled === false) {
-            return undefined;
-        }
-        if (!this.device.info.capabilities?.includes("render-targets")) {
-            throw new RenderDeviceError("Renderer-owned shadows require render targets", "SHADOW_RENDER_TARGET_UNSUPPORTED", {
-                backend: this.device.kind
-            });
-        }
-        const light = options.shadowOptions.light ?? firstShadowCastingLight(options.source, options.lights);
-        if (light instanceof PointLight) {
-            return this.executeRendererPointShadowMap({
-                shadowOptions: options.shadowOptions,
-                items: options.items,
-                ownedTargets: options.ownedTargets,
-                ownedShadowPasses: options.ownedShadowPasses,
-                light
-            });
-        }
-        if (light && !(light instanceof DirectionalLight) && !(light instanceof SpotLight)) {
-            throw new RenderDeviceError("Renderer-owned shadow maps require directional, spot, or point lights.", "SHADOW_LIGHT_TYPE_UNSUPPORTED", {
-                lightName: light.name,
-                lightType: light.constructor.name
-            });
-        }
-        if (light instanceof DirectionalLight
-            && options.camera instanceof PerspectiveCamera
-            && (options.shadowOptions.cascadeCount ?? 1) > 1) {
-            return this.executeRendererCascadedShadowMap({
-                shadowOptions: options.shadowOptions,
-                items: options.items,
-                ownedShadowPasses: options.ownedShadowPasses,
-                light,
-                camera: options.camera
-            });
-        }
-        const lightMatrix = options.shadowOptions.lightMatrix
-            ? toMat4(options.shadowOptions.lightMatrix, "shadow.lightMatrix")
-            : createRendererOwnedShadowMatrix(light, options.items, firstShadowCastingCollectedLight(options.lights));
-        const shadowMap = new ShadowMap({
-            size: options.shadowOptions.size,
-            bias: options.shadowOptions.bias,
-            filter: options.shadowOptions.filter,
-            pcfRadius: options.shadowOptions.pcfRadius,
-            pcfSamples: options.shadowOptions.pcfSamples,
-            pcfDistribution: options.shadowOptions.pcfDistribution,
-            label: options.shadowOptions.label ?? "renderer-shadow-map"
-        });
-        const shadowPass = new ShadowPass({
-            light,
-            casters: options.items,
-            shadowMap,
-            viewProjectionMatrix: lightMatrix,
-            shaderLibrary: this.shaderLibrary,
-            renderTarget: this.ensureShadowDepthTarget(shadowMap.size)
-        });
-        options.ownedShadowPasses.push(shadowPass);
-        const result = shadowPass.execute({ device: this.device, width: this.width, height: this.height });
-        if (!result.rendered) {
-            if (result.reason === "no-light" || result.reason === "light-disabled" || result.reason === "not-shadow-casting") {
-                throw new RenderDeviceError("Renderer-owned shadows require an enabled shadow-casting light.", "SHADOW_LIGHT_REQUIRED", {
-                    reason: result.reason
-                });
-            }
-            return undefined;
-        }
-        return shadowPass.getForwardShadowMap({
-            lightMatrix,
-            strength: options.shadowOptions.strength,
-            slopeBias: options.shadowOptions.slopeBias,
-            texelSize: options.shadowOptions.texelSize,
-            bias: options.shadowOptions.bias,
-            filterKernel: options.shadowOptions.filterKernel
-        }) ?? undefined;
-    }
-    executeRendererCascadedShadowMap(options) {
-        const cascadeCount = options.shadowOptions.cascadeCount ?? 4;
-        if (!Number.isInteger(cascadeCount) || cascadeCount < 2 || cascadeCount > 4) {
-            throw new RenderDeviceError("Renderer cascadeCount must be an integer in [2, 4].", "SHADOW_CASCADE_CONTRACT", { cascadeCount });
-        }
-        options.camera.transform.updateWorld(undefined, true);
-        const position = cameraWorldPosition(options.camera);
-        const world = options.camera.transform.worldMatrix;
-        const target = [
-            position[0] - (world[8] ?? 0),
-            position[1] - (world[9] ?? 0),
-            position[2] - (world[10] ?? 1)
-        ];
-        const cascades = new CascadedShadowMaps({
-            cascadeCount,
-            near: options.camera.near,
-            far: options.camera.far,
-            lambda: options.shadowOptions.cascadeLambda ?? 0.6,
-            size: options.shadowOptions.size,
-            bias: options.shadowOptions.bias,
-            filter: options.shadowOptions.filter,
-            pcfRadius: options.shadowOptions.pcfRadius,
-            pcfSamples: options.shadowOptions.pcfSamples,
-            label: options.shadowOptions.label ?? "renderer-csm"
-        });
-        const fits = cascades.computeStableCameraFits({
-            camera: {
-                position,
-                target,
-                fovYRadians: options.camera.fovYRadians,
-                aspect: options.camera.aspect
-            },
-            lightDirection: options.light.getDirection(),
-            casters: [],
-            receivers: [],
-            padding: options.shadowOptions.cascadePadding ?? 0.25,
-            stabilize: options.shadowOptions.stabilize !== false
-        });
-        const lightMatrices = fits.map(shadowCameraFitViewProjectionMatrix);
-        const cascadePass = new CascadedShadowPass({
-            light: options.light,
-            casters: options.items,
-            cascades,
-            viewProjectionMatrices: lightMatrices,
-            shaderLibrary: this.shaderLibrary
-        });
-        const result = cascadePass.execute({ device: this.device, width: this.width, height: this.height });
-        options.ownedShadowPasses.push(cascadePass);
-        if (!result.rendered)
-            return undefined;
-        const maps = cascadePass.getForwardShadowMaps({
-            lightMatrices,
-            strength: options.shadowOptions.strength,
-            slopeBias: options.shadowOptions.slopeBias,
-            texelSize: options.shadowOptions.texelSize,
-            bias: options.shadowOptions.bias,
-            filterKernel: options.shadowOptions.filterKernel
-        });
-        const first = maps[0];
-        if (!first || maps.length !== result.cascades.length)
-            return undefined;
-        return {
-            ...first,
-            cascades: result.cascades.map((cascade, index) => ({
-                index: cascade.index,
-                near: cascade.split.near,
-                far: cascade.split.far,
-                shadowMap: maps[index]
-            }))
-        };
-    }
-    executeRendererPointShadowMap(options) {
-        if (!this.device.writeRenderTargetPixels) {
-            throw new RenderDeviceError("Renderer-owned point shadows require render-target pixel upload for the point-light atlas.", "POINT_SHADOW_ATLAS_UPLOAD_UNSUPPORTED", {
-                backend: this.device.kind
-            });
-        }
-        options.light.transform.updateWorld(undefined, true);
-        const size = options.shadowOptions.size ?? 512;
-        const faceMatrices = createPointShadowFaceMatrices(options.light);
-        const faceRects = createPointShadowFaceRects();
-        const shadowMapOptions = {
-            size,
-            bias: options.shadowOptions.bias,
-            filter: options.shadowOptions.filter,
-            pcfRadius: options.shadowOptions.pcfRadius,
-            pcfSamples: options.shadowOptions.pcfSamples,
-            pcfDistribution: options.shadowOptions.pcfDistribution
-        };
-        const atlasPixels = new Uint8Array(size * 3 * size * 2 * 4);
-        for (let face = 0; face < 6; face += 1) {
-            const faceMatrix = faceMatrices.slice(face * 16, face * 16 + 16);
-            const shadowPass = new ShadowPass({
-                light: options.light,
-                casters: options.items,
-                shadowMap: new ShadowMap({ ...shadowMapOptions, label: `${options.shadowOptions.label ?? "renderer-point-shadow"}-face-${face}` }),
-                viewProjectionMatrix: faceMatrix,
-                shaderLibrary: this.shaderLibrary
-            });
-            options.ownedShadowPasses.push(shadowPass);
-            const result = shadowPass.execute({ device: this.device, width: this.width, height: this.height });
-            if (!result.rendered) {
-                return undefined;
-            }
-            const target = shadowPass.getRenderTarget();
-            if (!target) {
-                throw new RenderDeviceError("Renderer-owned point shadow face did not expose a render target.", "POINT_SHADOW_FACE_TARGET_MISSING", { face });
-            }
-            const facePixels = readShadowFacePixels(this.device, target);
-            blitPointShadowFace(atlasPixels, size * 3, size * 2, facePixels, size, faceRects, face);
-        }
-        const atlasTarget = this.device.createRenderTarget({
-            width: size * 3,
-            height: size * 2,
-            label: `${options.shadowOptions.label ?? "renderer-point-shadow"}-atlas`,
-            format: "rgba8",
-            depth: false
-        });
-        options.ownedTargets.push(atlasTarget);
-        this.device.writeRenderTargetPixels(atlasTarget, atlasPixels);
-        const texture = new TextureBinding({
-            name: "u_pointShadowMapTexture",
-            texture: atlasTarget.colorTexture,
-            sampler: new Sampler({ minFilter: "nearest", magFilter: "nearest", addressU: "clamp-to-edge", addressV: "clamp-to-edge" }),
-            required: true
-        });
-        return {
-            texture: new TextureBinding({
-                name: "u_shadowMapTexture",
-                texture: atlasTarget.colorTexture,
-                sampler: new Sampler({ minFilter: "nearest", magFilter: "nearest", addressU: "clamp-to-edge", addressV: "clamp-to-edge" }),
-                required: true
-            }),
-            lightMatrix: identityMat4(),
-            strength: options.shadowOptions.strength,
-            slopeBias: options.shadowOptions.slopeBias,
-            texelSize: options.shadowOptions.texelSize,
-            bias: options.shadowOptions.bias,
-            filterKernel: options.shadowOptions.filterKernel,
-            pointLight: {
-                texture,
-                lightPosition: [options.light.transform.worldMatrix[12], options.light.transform.worldMatrix[13], options.light.transform.worldMatrix[14]],
-                range: options.light.range,
-                faceMatrices,
-                faceRects,
-                strength: options.shadowOptions.strength,
-                slopeBias: options.shadowOptions.slopeBias,
-                texelSize: [1 / Math.max(1, size * 3), 1 / Math.max(1, size * 2)],
-                bias: options.shadowOptions.bias,
-                filterKernel: options.shadowOptions.filterKernel
-            }
-        };
+        return this.host.shadows.executeRendererShadowMap(options);
     }
 }
 export function pickSceneRenderables(source, ray, options = {}) {
@@ -1352,28 +1534,6 @@ function inferInitialCanvasDimension(canvas, axis) {
     const displaySize = Math.round(cssSize * dpr);
     return Math.max(1, displaySize || (axis === "width" ? canvas.width : canvas.height) || 1);
 }
-function collectEnvironmentLighting(source) {
-    if (source instanceof Scene || isIterable(source))
-        return undefined;
-    if (source.environmentLighting === false)
-        return cloneEnvironmentLighting(DISABLED_RENDERER_ENVIRONMENT_LIGHTING);
-    if (source.environmentLighting)
-        return source.environmentLighting;
-    return cloneEnvironmentLighting(DEFAULT_RENDERER_ENVIRONMENT_LIGHTING);
-}
-function collectEnvironmentBackground(source) {
-    if (source instanceof Scene || isIterable(source) || source.environmentBackground === false)
-        return undefined;
-    return source.environmentBackground;
-}
-function collectEnvironmentFog(source) {
-    if (source instanceof Scene || isIterable(source))
-        return undefined;
-    return source.environmentFog;
-}
-function collectForwardShadowMap(source) {
-    return source instanceof Scene || isIterable(source) ? undefined : source.shadowMap;
-}
 function collectRenderTarget(source) {
     return source instanceof Scene || isIterable(source) ? undefined : source.renderTarget;
 }
@@ -1395,206 +1555,6 @@ function validateExplicitRenderTarget(target, width, height) {
         });
     }
 }
-function collectRendererShadowOptions(source) {
-    if (source instanceof Scene || isIterable(source))
-        return undefined;
-    if (source.shadow === true)
-        return {};
-    if (!source.shadow)
-        return undefined;
-    return source.shadow;
-}
-function firstShadowCastingLight(source, lights) {
-    const explicit = lights.find((light) => light.castsShadow && light.source.visible)?.source;
-    if (explicit)
-        return explicit;
-    const scene = sceneFromSource(source);
-    return scene?.collectLights().find((light) => light.visible && light.castsShadow) ?? null;
-}
-function firstShadowCastingCollectedLight(lights) {
-    return lights.find((light) => light.castsShadow && light.source.visible);
-}
-function lightDirectionFromLight(light) {
-    if (!light)
-        return [0, -1, -1];
-    const direction = light instanceof DirectionalLight ? light.getDirection() : undefined;
-    return normalizeVec3([
-        Number(direction?.[0] ?? 0),
-        Number(direction?.[1] ?? -1),
-        Number(direction?.[2] ?? -1)
-    ]);
-}
-function createRendererOwnedShadowMatrix(light, items, collectedLight) {
-    if (light instanceof SpotLight) {
-        light.transform.updateWorld(undefined, true);
-        const near = 0.01;
-        const far = Math.max(near + 0.01, light.range);
-        const projectionMatrix = perspectiveMat4(light.angle * 2, 1, near, far);
-        return multiplyMat4(projectionMatrix, light.transform.inverseWorldMatrix);
-    }
-    return createDirectionalShadowMatrix(items, collectedLight?.direction ?? lightDirectionFromLight(light));
-}
-function createPointShadowFaceMatrices(light) {
-    light.transform.updateWorld(undefined, true);
-    const position = [
-        light.transform.worldMatrix[12],
-        light.transform.worldMatrix[13],
-        light.transform.worldMatrix[14]
-    ];
-    const projection = perspectiveMat4(Math.PI / 2, 1, 0.01, Math.max(0.02, light.range));
-    const faces = [
-        { direction: [1, 0, 0], up: [0, -1, 0] },
-        { direction: [-1, 0, 0], up: [0, -1, 0] },
-        { direction: [0, 1, 0], up: [0, 0, 1] },
-        { direction: [0, -1, 0], up: [0, 0, -1] },
-        { direction: [0, 0, 1], up: [0, -1, 0] },
-        { direction: [0, 0, -1], up: [0, -1, 0] }
-    ];
-    const matrices = new Float32Array(6 * 16);
-    for (const [index, face] of faces.entries()) {
-        const view = lookAtMatrix(position, addVec3(position, face.direction), face.up);
-        matrices.set(multiplyMat4(projection, view), index * 16);
-    }
-    return matrices;
-}
-function createPointShadowFaceRects() {
-    const rects = new Float32Array(6 * 4);
-    for (let face = 0; face < 6; face += 1) {
-        const column = face % 3;
-        const row = Math.floor(face / 3);
-        rects.set([column / 3, row / 2, 1 / 3, 1 / 2], face * 4);
-    }
-    return rects;
-}
-function readShadowFacePixels(device, target) {
-    device.setRenderTarget(target);
-    if (target.depthTexture && device.readDepthPixels) {
-        const depth = device.readDepthPixels(0, 0, target.width, target.height);
-        const pixels = new Uint8Array(target.width * target.height * 4);
-        for (let index = 0; index < depth.length; index += 1) {
-            const byte = Math.max(0, Math.min(255, Math.round((depth[index] ?? 1) * 255)));
-            const offset = index * 4;
-            pixels[offset] = byte;
-            pixels[offset + 1] = byte;
-            pixels[offset + 2] = byte;
-            pixels[offset + 3] = 255;
-        }
-        return pixels;
-    }
-    return device.readPixels(0, 0, target.width, target.height);
-}
-function blitPointShadowFace(atlasPixels, atlasWidth, atlasHeight, facePixels, faceSize, faceRects, face) {
-    const rectOffset = face * 4;
-    const destX = Math.round((faceRects[rectOffset] ?? 0) * atlasWidth);
-    const destY = Math.round((faceRects[rectOffset + 1] ?? 0) * atlasHeight);
-    for (let row = 0; row < faceSize; row += 1) {
-        const sourceOffset = row * faceSize * 4;
-        const targetOffset = ((destY + row) * atlasWidth + destX) * 4;
-        atlasPixels.set(facePixels.subarray(sourceOffset, sourceOffset + faceSize * 4), targetOffset);
-    }
-}
-function lookAtMatrix(eye, target, up) {
-    const forward = normalizeVec3(subtractVec3(target, eye));
-    const right = normalizeVec3(crossVec3(forward, up));
-    const correctedUp = crossVec3(right, forward);
-    return [
-        right[0], correctedUp[0], -forward[0], 0,
-        right[1], correctedUp[1], -forward[1], 0,
-        right[2], correctedUp[2], -forward[2], 0,
-        -dotVec3(right, eye), -dotVec3(correctedUp, eye), dotVec3(forward, eye), 1
-    ];
-}
-function createDirectionalShadowMatrix(items, lightDirection) {
-    const bounds = collectShadowCoverageBounds(items);
-    if (!bounds || bounds.isEmpty()) {
-        return identityMat4();
-    }
-    const basis = directionalLightBasis(lightDirection);
-    const points = boundsCorners(bounds).map((point) => projectPointToLightSpace(point, basis));
-    const lightBounds = boundsFromVec3(points);
-    const width = Math.max(0.01, lightBounds.max[0] - lightBounds.min[0]);
-    const height = Math.max(0.01, lightBounds.max[1] - lightBounds.min[1]);
-    const depth = Math.max(0.01, lightBounds.max[2] - lightBounds.min[2]);
-    const padding = Math.max(width, height, depth) * 0.08 + 0.05;
-    const viewMatrix = lightViewMatrix(basis);
-    const projectionMatrix = orthographicMat4(lightBounds.min[0] - padding, lightBounds.max[0] + padding, lightBounds.min[1] - padding, lightBounds.max[1] + padding, lightBounds.min[2] - padding, lightBounds.max[2] + padding);
-    return multiplyMat4(projectionMatrix, viewMatrix);
-}
-function directionalLightBasis(lightDirection) {
-    const forward = normalizeVec3(scaleVec3(normalizeVec3(lightDirection), -1));
-    const fallbackUp = Math.abs(forward[1]) > 0.94 ? [0, 0, 1] : [0, 1, 0];
-    const right = normalizeVec3(crossVec3(fallbackUp, forward));
-    const up = normalizeVec3(crossVec3(forward, right));
-    return { right, up, forward };
-}
-function lightViewMatrix(basis) {
-    return [
-        basis.right[0], basis.up[0], basis.forward[0], 0,
-        basis.right[1], basis.up[1], basis.forward[1], 0,
-        basis.right[2], basis.up[2], basis.forward[2], 0,
-        0, 0, 0, 1
-    ];
-}
-function projectPointToLightSpace(point, basis) {
-    return [dotVec3(point, basis.right), dotVec3(point, basis.up), dotVec3(point, basis.forward)];
-}
-function boundsCorners(bounds) {
-    return [
-        [bounds.min[0], bounds.min[1], bounds.min[2]],
-        [bounds.max[0], bounds.min[1], bounds.min[2]],
-        [bounds.min[0], bounds.max[1], bounds.min[2]],
-        [bounds.min[0], bounds.min[1], bounds.max[2]],
-        [bounds.max[0], bounds.max[1], bounds.min[2]],
-        [bounds.max[0], bounds.min[1], bounds.max[2]],
-        [bounds.min[0], bounds.max[1], bounds.max[2]],
-        [bounds.max[0], bounds.max[1], bounds.max[2]]
-    ];
-}
-function boundsFromVec3(points) {
-    const min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
-    const max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
-    for (const point of points) {
-        for (let axis = 0; axis < 3; axis += 1) {
-            min[axis] = Math.min(min[axis], point[axis]);
-            max[axis] = Math.max(max[axis], point[axis]);
-        }
-    }
-    return { min, max };
-}
-function normalizeVec3(value) {
-    const length = Math.hypot(value[0], value[1], value[2]);
-    if (!Number.isFinite(length) || length <= 1e-8)
-        return [0, -1 / Math.SQRT2, -1 / Math.SQRT2];
-    return [value[0] / length, value[1] / length, value[2] / length];
-}
-function scaleVec3(value, amount) {
-    return [value[0] * amount, value[1] * amount, value[2] * amount];
-}
-function addVec3(left, right) {
-    return [left[0] + right[0], left[1] + right[1], left[2] + right[2]];
-}
-function subtractVec3(left, right) {
-    return [left[0] - right[0], left[1] - right[1], left[2] - right[2]];
-}
-function crossVec3(left, right) {
-    return [
-        left[1] * right[2] - left[2] * right[1],
-        left[2] * right[0] - left[0] * right[2],
-        left[0] * right[1] - left[1] * right[0]
-    ];
-}
-function dotVec3(left, right) {
-    return left[0] * right[0] + left[1] * right[1] + left[2] * right[2];
-}
-function collectPostprocess(source) {
-    if (source instanceof Scene || isIterable(source))
-        return undefined;
-    if (source.postprocess === true)
-        return {};
-    if (!source.postprocess)
-        return undefined;
-    return source.postprocess;
-}
 function normalizeRendererInput(sourceOrInput, camera) {
     if (isRendererInput(sourceOrInput)) {
         return { source: sourceOrInput.source, camera: camera ?? sourceOrInput.camera };
@@ -1618,63 +1578,6 @@ function collectCameraPolicy(source) {
         return "auto-frame";
     return "identity";
 }
-function postprocessRequiresDepthTexture(postprocess) {
-    return Boolean((postprocess.volumetricLight && !postprocess.volumetricLight.depth) ||
-        (postprocess.depthOfField && !postprocess.depthOfField.depth) ||
-        (postprocess.contactShadow && !postprocess.contactShadow.depth) ||
-        (postprocess.ssao && !postprocess.ssao.depth) ||
-        (postprocess.ssr && !postprocess.ssr.depth));
-}
-function canFuseLdrPostprocess(source, passes) {
-    const sourceIsHdr = isHdrRenderTarget(source);
-    return passes.length > 0
-        && (!sourceIsHdr || passes[0]?.name === "tone-mapping" || (passes[0]?.name === "bloom" && passes[1]?.name === "tone-mapping"))
-        && passes.every((pass) => pass.name === "bloom" || pass.name === "tone-mapping" || pass.name === "color-grade" || pass.name === "depth-of-field" || pass.name === "motion-blur" || pass.name === "ssao" || pass.name === "ssr" || pass.name === "taa" || pass.name === "outline" || pass.name === "fxaa")
-        && passes.every((pass, index) => {
-            const previousRank = index === 0 ? -1 : ldrFusionPassRank(passes[index - 1].name);
-            return ldrFusionPassRank(pass.name) >= previousRank;
-        });
-}
-function ldrFusionPassRank(name) {
-    if (name === "bloom")
-        return -1;
-    if (name === "tone-mapping")
-        return 0;
-    if (name === "color-grade")
-        return 1;
-    if (name === "depth-of-field")
-        return 2;
-    if (name === "motion-blur")
-        return 3;
-    if (name === "ssao")
-        return 4;
-    if (name === "ssr")
-        return 5;
-    if (name === "taa")
-        return 6;
-    if (name === "outline")
-        return 7;
-    if (name === "fxaa")
-        return 8;
-    return Number.POSITIVE_INFINITY;
-}
-function isDepthPostprocessPass(name) {
-    return name === "volumetric-light" || name === "depth-of-field" || name === "contact-shadow" || name === "ssao" || name === "ssr";
-}
-function postprocessPassHasDepth(options) {
-    return typeof options === "object" && options !== null && "depth" in options && Boolean(options.depth);
-}
-function withRendererDepth(options, depth) {
-    return depth && !options.depth ? { ...options, depth } : options;
-}
-function defaultPostprocessTargetFormat(device, postprocess) {
-    if (postprocess.toneMapping === false)
-        return "rgba8";
-    return device.info.capabilities?.includes("hdr-render-targets") ? "rgba16f" : "rgba8";
-}
-function isHdrRenderTarget(target) {
-    return target.colorTexture.format === "rgba16f" || target.colorTexture.format === "rgba32f";
-}
 function collectSourceCameraPosition(source) {
     if (source instanceof Scene || isIterable(source))
         return undefined;
@@ -1691,21 +1594,28 @@ function collectSourceCameraPosition(source) {
 export function collectRenderItems(source, cameraViewProjection, camera) {
     return collectRenderItemsWithDiagnostics(source, cameraViewProjection, camera).items;
 }
-function collectRenderItemsWithDiagnostics(source, cameraViewProjection, camera) {
+function collectRenderItemsWithDiagnostics(source, cameraViewProjection, camera, keepCulledShadowCasters = false) {
     const diagnostics = createRenderCollectionDiagnostics();
+    // 02-S5 (A3D_QR_LIGHTING): frustum-culled items that still cast. A caster
+    // outside the view (a pole behind the camera under a low sun) must reach
+    // the shadow pass. Flag-off collects nothing extra.
+    const culledShadowCasters = keepCulledShadowCasters ? [] : undefined;
     if (isIterable(source)) {
         const items = applyViewProjection([...source], cameraViewProjection);
         diagnostics.submittedObjects += items.length;
         diagnostics.visibleObjects += items.length;
-        return { items, diagnostics };
+        return { items, diagnostics, culledShadowCasters: culledShadowCasters ?? [] };
     }
     if (source instanceof Scene) {
-        const items = collectSceneRenderItems(source, {}, cameraViewProjection, camera, diagnostics);
-        return { items, diagnostics };
+        const items = collectSceneRenderItems(source, {}, cameraViewProjection, camera, diagnostics, culledShadowCasters);
+        return { items, diagnostics, culledShadowCasters: culledShadowCasters ?? [], ...(camera ? { cullingFrustum: camera.frustum } : {}) };
     }
     const items = [];
+    let cullingFrustum;
     if (source.scene) {
-        items.push(...collectSceneRenderItems(source.scene, source, cameraViewProjection, source.frustumCulling === false ? undefined : camera, diagnostics));
+        if (source.frustumCulling !== false && camera)
+            cullingFrustum = camera.frustum;
+        items.push(...collectSceneRenderItems(source.scene, source, cameraViewProjection, source.frustumCulling === false ? undefined : camera, diagnostics, culledShadowCasters));
     }
     const explicitItems = [];
     if (source.collectRenderItems) {
@@ -1715,193 +1625,16 @@ function collectRenderItemsWithDiagnostics(source, cameraViewProjection, camera)
         explicitItems.push(...source.renderItems);
     }
     if (explicitItems.length > 0) {
-        const cullingFrustum = explicitCullingFrustum(source, cameraViewProjection, camera);
-        const visibleItems = cullExplicitRenderItems(explicitItems, cullingFrustum, diagnostics);
+        const explicitFrustum = explicitCullingFrustum(source, cameraViewProjection, camera);
+        cullingFrustum ??= explicitFrustum;
+        const visibleItems = cullExplicitRenderItems(explicitItems, explicitFrustum, diagnostics, culledShadowCasters);
         const optimizedItems = applyRendererOwnedStaticBatching(source, applyRendererOwnedStaticMeshConsolidation(source, visibleItems));
         const projectedItems = applyViewProjection(optimizedItems, cameraViewProjection);
         items.push(...projectedItems);
     }
-    return { items, diagnostics };
-}
-function explicitCullingFrustum(source, cameraViewProjection, camera) {
-    // Explicit render-item sources were historically never culled, so culling
-    // stays opt-in: only an explicit `frustumCulling: true` turns it on.
-    if (source.frustumCulling !== true)
-        return undefined;
-    if (camera)
-        return camera.frustum;
-    if (!cameraViewProjection)
-        return undefined;
-    return Frustum.fromMatrix(toMathMat4(cameraViewProjection));
-}
-function cullExplicitRenderItems(items, frustum, diagnostics) {
-    if (!frustum) {
-        diagnostics.submittedObjects += items.length;
-        diagnostics.visibleObjects += items.length;
-        return items;
-    }
-    const visible = [];
-    for (const item of items) {
-        diagnostics.submittedObjects += 1;
-        if (!isFrustumCullableRenderItem(item)) {
-            diagnostics.visibleObjects += 1;
-            visible.push(item);
-            continue;
-        }
-        diagnostics.frustumTestedObjects += 1;
-        const bounds = explicitRenderItemWorldBounds(item);
-        if (!frustum.intersectsBox(bounds.toMathBox())) {
-            diagnostics.culledObjects += 1;
-            continue;
-        }
-        diagnostics.visibleObjects += 1;
-        visible.push(item);
-    }
-    return visible;
-}
-function isFrustumCullableRenderItem(item) {
-    if (item.drawRange !== undefined)
-        return false;
-    if (item.morphTargets !== undefined || item.morphWeights !== undefined)
-        return false;
-    return true;
-}
-function explicitRenderItemWorldBounds(item) {
-    const modelMatrix = toMat4(item.modelMatrix ?? identityMat4(), "modelMatrix", item.label);
-    if (item.skinning) {
-        const local = skinnedItemLocalBounds(item.geometry, item.skinning);
-        return boundsFromLocal(local, modelMatrix, item.instanceTransforms);
-    }
-    return boundsFromLocal(item.geometry.bounds, modelMatrix, item.instanceTransforms);
-}
-function boundsFromLocal(envelope, modelMatrix, instanceTransforms) {
-    const local = new SceneBounds3([envelope.min[0], envelope.min[1], envelope.min[2]], [envelope.max[0], envelope.max[1], envelope.max[2]]);
-    if (!instanceTransforms || instanceTransforms.length < 16) {
-        return local.transform(modelMatrix);
-    }
-    let bounds = new SceneBounds3();
-    for (let offset = 0; offset + 16 <= instanceTransforms.length; offset += 16) {
-        const instanceMatrix = toMat4(instanceTransforms.slice(offset, offset + 16), "instanceTransforms");
-        bounds = bounds.union(local.transform(multiplyMat4(modelMatrix, instanceMatrix)));
-    }
-    return bounds;
-}
-const skinnedCullingBoundsCache = new WeakMap();
-function skinnedItemLocalBounds(geometry, skinning) {
-    const cached = skinnedCullingBoundsCache.get(geometry);
-    if (cached && float32ArraysEqual(cached.matrices, skinning.matrices)) {
-        return cached.bounds;
-    }
-    const bounds = computeSkinnedGeometryBounds(geometry, skinning);
-    skinnedCullingBoundsCache.set(geometry, { matrices: new Float32Array(skinning.matrices), bounds });
-    return bounds;
+    return { items, diagnostics, culledShadowCasters: culledShadowCasters ?? [], ...(cullingFrustum ? { cullingFrustum } : {}) };
 }
-function float32ArraysEqual(left, right) {
-    if (left.length !== right.length)
-        return false;
-    for (let index = 0; index < left.length; index += 1) {
-        if (left[index] !== right[index])
-            return false;
-    }
-    return true;
-}
-const staticBatchGeometryIds = new WeakMap();
-const staticBatchMaterialIds = new WeakMap();
-let nextStaticBatchResourceId = 1;
-/**
- * Merges shared-material static geometry, then hands the result to batching.
- *
- * Consolidation runs first because it reduces distinct geometries; whatever it leaves unmerged (single
- * items, oversized meshes, non-indexed topology) can still be instanced by batching afterwards.
- */
-const staticMeshConsolidationCaches = new WeakMap();
-function applyRendererOwnedStaticMeshConsolidation(source, items) {
-    if (!source.staticMeshConsolidation)
-        return items;
-    const mergeable = [];
-    const passthrough = [];
-    for (const item of items) {
-        // The same eligibility rule as batching: anything skinned, morphed, instanced, or draw-ranged is
-        // not static geometry and must not have a transform baked into it.
-        if (isStaticBatchCandidate(item)) {
-            mergeable.push({
-                geometry: item.geometry,
-                material: item.material,
-                modelMatrix: item.modelMatrix ?? identityMat4(),
-                ...(item.label ? { label: item.label } : {})
-            });
-        }
-        else {
-            passthrough.push(item);
-        }
-    }
-    if (mergeable.length === 0)
-        return items;
-    const options = source.staticMeshConsolidation === true ? {} : source.staticMeshConsolidation;
-    // Cached per render source: merging walks every vertex, so repeating it each frame costs far more
-    // than the draw calls it saves.
-    let cache = staticMeshConsolidationCaches.get(source);
-    if (!cache) {
-        cache = createStaticMeshConsolidationCache();
-        staticMeshConsolidationCaches.set(source, cache);
-    }
-    const consolidated = cache.consolidate(mergeable, {
-        labelPrefix: "renderer-consolidated-mesh",
-        ...options
-    });
-    return [...passthrough, ...consolidated.renderItems];
-}
-function applyRendererOwnedStaticBatching(source, items) {
-    if (!source.staticBatching)
-        return items;
-    const batchable = [];
-    const passthrough = [];
-    for (const item of items) {
-        if (isStaticBatchCandidate(item)) {
-            batchable.push({
-                geometry: item.geometry,
-                material: item.material,
-                modelMatrix: item.modelMatrix ?? identityMat4(),
-                batchKey: staticBatchKey(item),
-                label: item.label,
-                castShadow: item.castShadow
-            });
-        }
-        else {
-            passthrough.push(item);
-        }
-    }
-    if (batchable.length === 0)
-        return items;
-    const options = source.staticBatching === true ? {} : source.staticBatching;
-    const batched = batchStaticRenderItems(batchable, {
-        labelPrefix: "renderer-static-batch",
-        ...options
-    });
-    return [...passthrough, ...batched.renderItems];
-}
-function isStaticBatchCandidate(item) {
-    return item.material !== undefined &&
-        item.drawRange === undefined &&
-        item.skinning === undefined &&
-        item.morphTargets === undefined &&
-        item.morphWeights === undefined &&
-        item.instanceTransforms === undefined &&
-        item.instanceColors === undefined &&
-        item.instanceAttributes === undefined;
-}
-function staticBatchKey(item) {
-    return `${resourceId(staticBatchGeometryIds, item.geometry)}:${resourceId(staticBatchMaterialIds, item.material)}:shadow-${item.castShadow !== false ? "on" : "off"}`;
-}
-function resourceId(ids, resource) {
-    const existing = ids.get(resource);
-    if (existing !== undefined)
-        return existing;
-    const next = nextStaticBatchResourceId++;
-    ids.set(resource, next);
-    return next;
-}
-function collectSceneRenderItems(scene, source, cameraViewProjection, camera, diagnostics) {
+function collectSceneRenderItems(scene, source, cameraViewProjection, camera, diagnostics, culledShadowCasters) {
     scene.updateWorldTransforms();
     const renderables = scene.collectRenderables();
     if (renderables.length === 0) {
@@ -1943,14 +1676,14 @@ function collectSceneRenderItems(scene, source, cameraViewProjection, camera, di
             if (camera)
                 diagnostics.frustumTestedObjects += 1;
         }
-        if (camera && !camera.frustum.intersectsBox(bounds.toMathBox())) {
-            if (diagnostics)
-                diagnostics.culledObjects += 1;
+        const culled = camera !== undefined && !camera.frustum.intersectsBox(bounds.toMathBox());
+        if (culled && diagnostics)
+            diagnostics.culledObjects += 1;
+        if (culled && !culledShadowCasters)
             continue;
-        }
-        if (diagnostics)
+        if (!culled && diagnostics)
             diagnostics.visibleObjects += 1;
-        items.push({
+        (culled ? culledShadowCasters : items).push({
             geometry,
             material,
             label: node.name,
@@ -1965,7 +1698,12 @@ function collectSceneRenderItems(scene, source, cameraViewProjection, camera, di
     }
     return items;
 }
-function createRenderCollectionDiagnostics() {
+/** Travel direction of the first shadow-casting directional light (02-S5). */
+function shadowSunTravel(lights) {
+    const sun = lights.find((light) => light.kind === "directional" && light.castsShadow);
+    return sun ? [sun.direction[0], sun.direction[1], sun.direction[2]] : undefined;
+}
+export function createRenderCollectionDiagnostics() {
     return {
         submittedObjects: 0,
         visibleObjects: 0,
@@ -1973,29 +1711,6 @@ function createRenderCollectionDiagnostics() {
         frustumTestedObjects: 0
     };
 }
-function createPostprocessDiagnostics(postprocess, ownedTargets, width, height, context = {}) {
-    if (!postprocess)
-        return undefined;
-    const passes = createRendererPostprocessPasses(postprocess);
-    const targetFormat = context.targetFormat ?? postprocess.targetFormat ?? "rgba8";
-    return {
-        postprocessPasses: passes.length,
-        postprocessPassNames: passes.map((pass) => pass.name),
-        postprocessTargetFormat: targetFormat,
-        postprocessRenderTargets: ownedTargets.length,
-        postprocessTextures: ownedTargets.reduce((total, target) => total + 1 + (target.depthTexture ? 1 : 0), 0),
-        postprocessTargetWidth: width,
-        postprocessTargetHeight: height,
-        postprocessPlan: createRendererPostprocessPlanDiagnostics(postprocess, {
-            sourceTargetFormat: targetFormat,
-            targetFormat,
-            nativeLdrPostprocess: context.nativeLdrPostprocess,
-            rendererDepthAvailable: context.rendererDepthAvailable,
-            width,
-            height
-        })
-    };
-}
 const CAPTURE_NON_BLANK_LUMINANCE_THRESHOLD = 1 / 255;
 const CAPTURE_UNDEREXPOSED_LUMINANCE_THRESHOLD = 5 / 255;
 const CAPTURE_OVEREXPOSED_LUMINANCE_THRESHOLD = 250 / 255;
@@ -2255,19 +1970,6 @@ function withRendererFrameDiagnostics(diagnostics, collection, postprocess) {
         ...(postprocess ?? {})
     };
 }
-function renderableWorldBounds(geometry, modelMatrix, instanceTransforms, morphTargets, morphWeights, skinning) {
-    const envelope = computeSkinnedMorphTargetWeightedBounds(geometry, skinning, morphTargets, morphWeights);
-    const local = new SceneBounds3([envelope.min[0], envelope.min[1], envelope.min[2]], [envelope.max[0], envelope.max[1], envelope.max[2]]);
-    if (!instanceTransforms) {
-        return local.transform(modelMatrix);
-    }
-    let bounds = new SceneBounds3();
-    for (let offset = 0; offset < instanceTransforms.length; offset += 16) {
-        const instanceMatrix = toMat4(instanceTransforms.slice(offset, offset + 16), "instanceTransforms");
-        bounds = bounds.union(local.transform(multiplyMat4(modelMatrix, instanceMatrix)));
-    }
-    return bounds;
-}
 function applyViewProjection(items, cameraViewProjection) {
     const hasCameraViewProjection = cameraViewProjection !== undefined;
     const viewProjection = cameraViewProjection ?? identityMat4();
@@ -2306,30 +2008,6 @@ function createAutoFrameCamera(source, items, width, height) {
 function collectRenderItemBounds(items) {
     return collectItemBounds(items, true);
 }
-/**
- * Bounds over every render item, including those excluded from camera
- * auto-framing.
- *
- * `includeInAutoFrame` answers "should the camera frame this?", which is a
- * composition choice. It must not decide which geometry a shadow frustum covers:
- * a large ground plane or backdrop is commonly excluded from auto-framing while
- * still being the surface that receives shadows. Fitting the light frustum to the
- * auto-frame subset shrinks it to the caster alone, so the receiver falls outside
- * the shadow map and no shadow is ever visible.
- */
-function collectShadowCoverageBounds(items) {
-    return collectItemBounds(items, false);
-}
-function collectItemBounds(items, respectAutoFrameExclusion) {
-    let bounds;
-    for (const item of items) {
-        if (respectAutoFrameExclusion && item.includeInAutoFrame === false)
-            continue;
-        const itemBounds = renderableWorldBounds(item.geometry, toMat4(item.modelMatrix ?? identityMat4(), "modelMatrix", item.label), item.instanceTransforms, item.morphTargets, item.morphWeights, item.skinning);
-        bounds = bounds ? bounds.union(itemBounds) : itemBounds;
-    }
-    return bounds;
-}
 function collectCameraFrameOptions(source) {
     if (source instanceof Scene || isIterable(source) || !source.cameraFrameOptions)
         return {};
@@ -2398,7 +2076,7 @@ function resolveCamera(source, camera, viewport, options = {}) {
 function hasExplicitAutoFrameCameraPolicy(source) {
     return !(source instanceof Scene) && !isIterable(source) && source.cameraPolicy === "auto-frame";
 }
-function cameraWorldPosition(camera) {
+export function cameraWorldPosition(camera) {
     const matrix = camera.transform.worldMatrix;
     return [matrix[12] ?? 0, matrix[13] ?? 0, matrix[14] ?? 0];
 }
@@ -2413,9 +2091,6 @@ function maybeCameraResize(camera) {
 function resolveSceneCamera(source) {
     return sceneFromSource(source)?.collectCameras()[0];
 }
-function sceneFromSource(source) {
-    return source instanceof Scene ? source : isIterable(source) ? undefined : source.scene;
-}
 function normalMatrixFromModel(modelMatrix) {
     let matrix;
     try {
@@ -2446,17 +2121,6 @@ function transposeMat4(matrix) {
         matrix[3], matrix[7], matrix[11], matrix[15]
     ];
 }
-function toMat4(value, field, label) {
-    const values = Array.from(value);
-    if (values.length !== 16 || !values.every(Number.isFinite)) {
-        throw new RenderDeviceError("Renderer matrix inputs must be finite mat4 values", "RENDERER_MATRIX_CONTRACT", {
-            field,
-            label,
-            scalars: values.length
-        });
-    }
-    return values;
-}
 function lookupRenderResource(lookup, key) {
     if (isReadonlyMap(lookup)) {
         return lookup.get(key);
@@ -2524,33 +2188,4 @@ function normalizeDefaultLightDirection(direction) {
     }
     return [direction[0] / length, direction[1] / length, direction[2] / length];
 }
-function cloneEnvironmentLighting(environment) {
-    return {
-        color: [...environment.color],
-        intensity: environment.intensity,
-        ...(environment.proceduralMap
-            ? {
-                proceduralMap: {
-                    skyColor: [...environment.proceduralMap.skyColor],
-                    horizonColor: [...environment.proceduralMap.horizonColor],
-                    groundColor: [...environment.proceduralMap.groundColor],
-                    specularColor: [...environment.proceduralMap.specularColor],
-                    intensity: environment.proceduralMap.intensity,
-                    specularIntensity: environment.proceduralMap.specularIntensity
-                }
-            }
-            : {}),
-        ...(environment.environmentMapTexture ? { environmentMapTexture: environment.environmentMapTexture } : {}),
-        ...(environment.environmentCubeMapTexture ? { environmentCubeMapTexture: environment.environmentCubeMapTexture } : {}),
-        ...(environment.environmentMapIntensity !== undefined ? { environmentMapIntensity: environment.environmentMapIntensity } : {}),
-        ...(environment.environmentMapSpecularIntensity !== undefined ? { environmentMapSpecularIntensity: environment.environmentMapSpecularIntensity } : {}),
-        ...(environment.environmentMapRotation !== undefined ? { environmentMapRotation: environment.environmentMapRotation } : {}),
-        ...(environment.environmentMapMipCount !== undefined ? { environmentMapMipCount: environment.environmentMapMipCount } : {}),
-        ...(environment.environmentMapEncoding ? { environmentMapEncoding: environment.environmentMapEncoding } : {}),
-        ...(environment.environmentBrdfLutTexture ? { environmentBrdfLutTexture: environment.environmentBrdfLutTexture } : {})
-    };
-}
-function isIterable(value) {
-    return typeof value[Symbol.iterator] === "function";
-}
 //# sourceMappingURL=Renderer.js.map