@photivra/engine 2.21.0 → 2.22.0

package/dist/gpu/display-view-quality-gpu.d.ts

@@ -2,9 +2,7 @@
  * Host side of the display view's Quality path on the GPU (#479): the support check, the float64 tables (the lattice groups
  * and their combined diffraction kernels per material and channel, as the reference forms them; the bilinear and AHD
  * candidate kernels; the footprint geometry), the three passes per band of display rows (lattice materials, site moments,
- * display pixels; `wgsl-display-view-quality-kernel.ts`), the low-signal correction states (computed on the host with the
- * reference's own `computeDisplayViewCorrectionStates`, #447, uploaded as a sorted table and grown from the grid keys the
- * kernel records), and the reference's own float64 finishing per display pixel (`finishDisplayViewPixel` of the Speed host:
+ * display pixels; `wgsl-display-view-quality-kernel.ts`), and the reference's own float64 finishing per display pixel (`finishDisplayViewPixel` of the Speed host:
  * the quantization term, the seeded noise draw, the Cholesky factor, the clipped centre, the sRGB encode and the rounding),
  * so the noise draw is bit-identical to the CPU's.
  *
@@ -16,19 +14,21 @@
  *
  * The float64 reference is `renderDisplayView` (facade/display-view.ts) on the exact-area-mean path with
  * `createDisplayViewExpectedSignal` (facade/expected-signal.ts), chart materials, with or without diffraction kernels,
- * the bilinear or the AHD candidates and the low-signal correction. Internal: not exported from the package.
+ * the bilinear or the AHD candidates. Internal: not exported from the package.
  *
- * Flagged display pixels (an uncertain lattice material among the sites read, a missing correction state after the
- * states were computed, a correction-threshold decision within its bound, AHD's choice on the noise-free mosaic able to move
+ * #594: this module and its WGSL load on demand (`prepareDisplayViewQualityGpu` in `display-view-gpu-renderer.ts`, a dynamic
+ * import), at the first render that takes the Quality passes; the renderer and the Speed path never import it statically.
+ *
+ * Flagged display pixels (an uncertain lattice material among the sites read, AHD's choice on the noise-free mosaic able to move
  * the pixel by more than DISPLAY_VIEW_QUALITY_CHOICE_SIGMA of its noise (#457), a non-finite output) are recomputed with the
  * reference, so they are exact. Every stage's wall-clock time is reported (`stageMilliseconds`); on a software adapter it
  * is not GPU performance.
  */
-import { type DisplayViewKernelTap, type DisplayViewRenderResult, type DisplayViewSetup } from "../facade/display-view.js";
+import { type DisplayViewRenderResult, type DisplayViewSetup } from "../facade/display-view.js";
 import { type DisplayViewExpectedSignalInput } from "../facade/expected-signal.js";
 import type { DisplayViewGpuSetup } from "../facade/display-view.js";
-import { type DisplayViewMaterialModules } from "./display-view-composite-material-module.js";
-import { type DisplayViewGpuConformanceCase, type DisplayViewGpuRenderer, type DisplayViewGpuRendererFactory, type DisplayViewGpuRequest } from "../facade/display-view-gpu.js";
+import type { DisplayViewMaterialModules } from "./display-view-composite-material-module.js";
+import type { DisplayViewGpuConformanceCase } from "../facade/display-view-gpu.js";
 import { type DisplayViewGpuMaterialModule } from "./display-view-speed-gpu.js";
 import { type ImageKernelExecution, type ImageKernelRelativeErrorBound } from "./image-kernel-execution.js";
 import { GpuResourceScope, type WebGpuRuntime } from "./webgpu-runtime.js";
@@ -56,8 +56,6 @@ export interface DisplayViewQualityGpuInput {
     material: DisplayViewGpuMaterialModule;
     /** Recompute flagged display pixels with the reference. Default true. */
     recomputeFlagged?: boolean;
-    /** The states this renderer holds for the setup's correction key (grown by the render); a fresh store when absent. */
-    states?: CorrectionStateStore;
     /**
      * #492: sum each site's taps in blocks (rows, groups; `DISPLAY_VIEW_QUALITY_SITES_BLOCKED_WGSL`), whose bound grows with the
      * kernel's width rather than its tap count. Default: when the setup's expected signal carries the defocus disc
@@ -92,16 +90,12 @@ export interface DisplayViewQualityStageTimings {
     lattice: number;
     /** Pass 2: the site electrons through the combined kernels, the readout moments and the white clip. */
     sites: number;
-    /** Pass 3: the display pixels (demosaic candidates, development, covariance, correction), every dispatch of it. */
+    /** Pass 3: the display pixels (demosaic candidates, development, covariance), every dispatch of it. */
     pixels: number;
-    /** The low-signal correction states computed on the host (the reference's own draws) and the table uploads. */
-    states: number;
     /** The host finishing (quantization term, noise draw, Cholesky, encode) of every display pixel. */
     finishing: number;
     /** The reference's recomputation of flagged display pixels. */
     recompute: number;
-    /** Pass 3 dispatches that were repeated because a correction state was missing. */
-    pixelRedispatches: number;
     /** Pass 2 dispatches (one per band, or more where a band's sites × taps exceed the tap budget per dispatch, #492). */
     siteDispatches: number;
 }
@@ -122,9 +116,6 @@ export interface DisplayViewQualityGpuResult extends DisplayViewRenderResult {
     pixelFlags: Uint32Array;
     /** #533: display pixels (not flagged) with a real pixel whose saturation the kernel left undecided; their count is the host reference's. */
     highlightRecomputedPixelIndices: Uint32Array;
-    /** Correction states the render computed on the host (new to the store), and the states the table held at the end. */
-    statesComputed: number;
-    statesHeld: number;
     /** Taps per native site of the expected-signal gather (over every lattice group). */
     tapsPerSite: number;
     /** #492: whether the site pass summed in blocks (the defocus disc), and the relative bound of a site's electrons it used. */
@@ -137,33 +128,10 @@ export interface DisplayViewQualityGpuResult extends DisplayViewRenderResult {
     latticePointsResolved: number;
     stageMilliseconds: DisplayViewQualityStageTimings;
 }
-/**
- * The low-signal correction states a renderer holds for one correction key, as the GPU table reads them: grid keys ascending
- * with three float32 values each (the host keeps the float64 values; the table is their single rounding).
- */
-export declare class CorrectionStateStore {
-    #private;
-    get size(): number;
-    has(key: number): boolean;
-    add(gridKeys: Int32Array, values: Float64Array): void;
-    /** The sorted table (rebuilt when states were added since the last call). */
-    table(): {
-        keys: Int32Array<ArrayBuffer>;
-        values: Float32Array<ArrayBuffer>;
-    };
-}
-/** The footprint shape of a view: real pixels per display pixel along each axis, and whether the exact area mean applies. */
-export declare function footprintShape(setup: DisplayViewSetup): {
-    sx: number;
-    sy: number;
-    exact: boolean;
-    maximumColumns: number;
-    maximumRows: number;
-};
 /**
  * Why the Quality kernels do not cover a request, or null when they do: chart materials, the exact area mean (footprints of
  * at most 25 real pixels and 6 per axis), the identity or positive Reinhard tone curve, demosaic candidates within 3 sites
- * (1 or 2 per phase), at most 64 lattice groups, lattice constants exact in float32, no collect pass, and a raster at least
+ * (1 or 2 per phase), at most 64 lattice groups, lattice constants exact in float32, and a raster at least
  * 2·reach + 2 sites on each axis (so a reflected border site lies in the band's window).
  */
 export declare function displayViewQualityGpuUnsupportedReason(setup: DisplayViewSetup, signalInput: DisplayViewExpectedSignalInput): string | null;
@@ -229,29 +197,10 @@ export declare function renderDisplayViewQualityOnGpu(runtime: WebGpuRuntime, ba
 export declare function qualityMaterialSetup(gpu: DisplayViewGpuSetup): DisplayViewGpuSetup;
 /** The material module of a Quality render's scene (see `qualityMaterialSetup`). */
 export declare function qualityMaterialModule(modules: DisplayViewMaterialModules, gpu: DisplayViewGpuSetup, signal: AbortSignal): Promise<DisplayViewGpuMaterialModule>;
-/** The pixel-aperture samples per axis and anti-aliasing spots of a request. */
-export declare function offsetCount(request: DisplayViewGpuRequest): number;
-/**
- * Why the Quality renderer does not support a prepared request (`DisplayViewGpuRenderer.supports`), or true: engine charts and
- * declared `material-layers` scenes (the material modules of `createDisplayViewMaterialModules`, #491), the identity or Reinhard
- * tone curve and at most 64 query offsets (lattice groups). `lens.defocus` out of focus is supported (#492 step 2c: the site pass
- * gathers the disc, or each node's diffraction kernel convolved with it, up to the reference's own caps of radius 64 and 96);
- * whether a view's footprints take the exact area mean, whether the device passes the composite probe, and whether the kernel
- * table fits the device's storage binding limit, is known only per render.
- */
-export declare function displayViewQualityGpuSupports(request: DisplayViewGpuRequest): true | string;
 /** #479's self-check (see `runQualityConformance`). */
 export declare const DISPLAY_VIEW_QUALITY_CONFORMANCE_CASE: DisplayViewGpuConformanceCase;
 /** #492's self-check of the defocus disc's blocked site sum (see `runQualityConformance`). */
 export declare const DISPLAY_VIEW_QUALITY_DEFOCUS_CONFORMANCE_CASE: DisplayViewGpuConformanceCase;
-/** The bilinear RGGB demosaic kernels per phase (phaseY·2 + phaseX) and channel, as `bilinearPhaseProfiles` gives them. */
-export declare function bilinearKernels(): DisplayViewKernelTap[][][];
-export declare function createDisplayViewGpuRenderer(runtime: WebGpuRuntime, options?: {
-    maximumBandBytes?: number;
-    yieldControl?: YieldControl;
-}): DisplayViewGpuRenderer;
-/** The factory `prepareDisplayView` creates the renderer with (one per device): the Speed and Quality kernels behind one renderer. */
-export declare const displayViewGpuRendererFactory: DisplayViewGpuRendererFactory;
-/** Registers the combined renderer as the display view's GPU renderer and returns the factory registered before. */
-export declare function registerDisplayViewGpuRenderer(): DisplayViewGpuRendererFactory | null;
+/** #594: the Quality kernels' self-check cases, run before the first render that takes the Quality passes (`onDemandConformanceCases`). */
+export declare const DISPLAY_VIEW_QUALITY_CONFORMANCE_CASES: readonly DisplayViewGpuConformanceCase[];
 export {};

package/dist/gpu/display-view-quality-gpu.js

@@ -3,9 +3,7 @@
  * Host side of the display view's Quality path on the GPU (#479): the support check, the float64 tables (the lattice groups
  * and their combined diffraction kernels per material and channel, as the reference forms them; the bilinear and AHD
  * candidate kernels; the footprint geometry), the three passes per band of display rows (lattice materials, site moments,
- * display pixels; `wgsl-display-view-quality-kernel.ts`), the low-signal correction states (computed on the host with the
- * reference's own `computeDisplayViewCorrectionStates`, #447, uploaded as a sorted table and grown from the grid keys the
- * kernel records), and the reference's own float64 finishing per display pixel (`finishDisplayViewPixel` of the Speed host:
+ * display pixels; `wgsl-display-view-quality-kernel.ts`), and the reference's own float64 finishing per display pixel (`finishDisplayViewPixel` of the Speed host:
  * the quantization term, the seeded noise draw, the Cholesky factor, the clipped centre, the sRGB encode and the rounding),
  * so the noise draw is bit-identical to the CPU's.
  *
@@ -17,25 +15,26 @@
  *
  * The float64 reference is `renderDisplayView` (facade/display-view.ts) on the exact-area-mean path with
  * `createDisplayViewExpectedSignal` (facade/expected-signal.ts), chart materials, with or without diffraction kernels,
- * the bilinear or the AHD candidates and the low-signal correction. Internal: not exported from the package.
+ * the bilinear or the AHD candidates. Internal: not exported from the package.
  *
- * Flagged display pixels (an uncertain lattice material among the sites read, a missing correction state after the
- * states were computed, a correction-threshold decision within its bound, AHD's choice on the noise-free mosaic able to move
+ * #594: this module and its WGSL load on demand (`prepareDisplayViewQualityGpu` in `display-view-gpu-renderer.ts`, a dynamic
+ * import), at the first render that takes the Quality passes; the renderer and the Speed path never import it statically.
+ *
+ * Flagged display pixels (an uncertain lattice material among the sites read, AHD's choice on the noise-free mosaic able to move
  * the pixel by more than DISPLAY_VIEW_QUALITY_CHOICE_SIGMA of its noise (#457), a non-finite output) are recomputed with the
  * reference, so they are exact. Every stage's wall-clock time is reported (`stageMilliseconds`); on a software adapter it
  * is not GPU performance.
  */
-import { AHD_KEY_LEVELS, EXACT_AREA_MEAN_MAX_PIXELS, axisSums, computeDisplayViewCorrectionStates, displayViewCorrectionKey, displayViewDecidedSaturation, overlaps, renderDisplayView, ahdCandidateKernels } from "../facade/display-view.js";
+import { axisSums, displayViewDecidedSaturation, overlaps, renderDisplayView, ahdCandidateKernels } from "../facade/display-view.js";
 import { displayViewSignalTables } from "../facade/expected-signal.js";
-import { createDisplayViewMaterialModules } from "./display-view-composite-material-module.js";
-import { setDisplayViewGpuRendererFactory } from "../facade/display-view-gpu.js";
 import { chartPresetMaterialModule } from "./display-view-chart-material-module.js";
-import { DISPLAY_VIEW_SPEED_CONFORMANCE_CASE, CONFORMANCE_FRAME, recomputeRuns, sceneToneAndOffsetsReason, conformanceChannelAt, conformanceChart, conformanceResponses, conformanceSetup, conformanceVerdict, withConformanceAbort, axisRecord, displayViewSpeedGpuSupports, displayViewSpeedGpuUnsupportedReason, finishDisplayViewPixel, gaussLegendre16, queryGeometry, renderDisplayViewSpeedOnGpu } from "./display-view-speed-gpu.js";
+import { CONFORMANCE_FRAME, LARGE_DEFOCUS_REASON, recomputeRuns, footprintShape, conformanceChannelAt, conformanceChart, conformanceResponses, conformanceSetup, conformanceVerdict, withConformanceAbort, axisRecord, finishDisplayViewPixel, gaussLegendre16, queryGeometry } from "./display-view-speed-gpu.js";
 import { createHostYieldGate } from "../capture/host-yield-cadence.js";
 import { createDefocusDiscSiteKernel } from "../optics/defocus-disc-kernel.js";
 import { ImageKernelExecutionError, WEBGPU_F32_UNIT_ROUNDOFF, webGpuExecution } from "./image-kernel-execution.js";
-import { BUFFER_USAGE, GpuResourceScope, abortedError, createComputePipeline, linearDispatch, runComputePass, throwIfAborted as checkAbort } from "./webgpu-runtime.js";
-import { DISPLAY_VIEW_QUALITY_AUX, DISPLAY_VIEW_QUALITY_BITMAP_WORDS, DISPLAY_VIEW_QUALITY_CANDIDATE_ENTRIES, DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS, DISPLAY_VIEW_QUALITY_FLAG, DISPLAY_VIEW_QUALITY_FLAG_WORDS, DISPLAY_VIEW_QUALITY_GEOMETRY_STRIDE, DISPLAY_VIEW_QUALITY_GROUP_WORDS, DISPLAY_VIEW_QUALITY_MAXIMUM_NODES, DISPLAY_VIEW_QUALITY_MAXIMUM_PIXELS_PER_AXIS, DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS, DISPLAY_VIEW_QUALITY_PARAM_WORDS, DISPLAY_VIEW_QUALITY_PIXELS_WGSL, DISPLAY_VIEW_QUALITY_SITES_BLOCKED_WGSL, DISPLAY_VIEW_QUALITY_SITES_WGSL, DISPLAY_VIEW_QUALITY_SITE_FLOATS, DISPLAY_VIEW_QUALITY_TAP_WORDS, DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE, assembleDisplayViewQualityLatticeWgsl } from "./wgsl-display-view-quality-kernel.js";
+import { BUFFER_USAGE, GpuResourceScope, linearDispatch, runComputePass, throwIfAborted as checkAbort } from "./webgpu-runtime.js";
+import { DISPLAY_VIEW_QUALITY_AUX, DISPLAY_VIEW_QUALITY_CANDIDATE_ENTRIES, DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS, DISPLAY_VIEW_QUALITY_FLAG, DISPLAY_VIEW_QUALITY_FLAG_WORDS, DISPLAY_VIEW_QUALITY_GEOMETRY_STRIDE, DISPLAY_VIEW_QUALITY_GROUP_WORDS, DISPLAY_VIEW_QUALITY_MAXIMUM_NODES, DISPLAY_VIEW_QUALITY_MAXIMUM_PIXELS_PER_AXIS, DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS, DISPLAY_VIEW_QUALITY_PARAM_WORDS, DISPLAY_VIEW_QUALITY_PIXELS_WGSL, DISPLAY_VIEW_QUALITY_SITES_BLOCKED_WGSL, DISPLAY_VIEW_QUALITY_SITES_WGSL, DISPLAY_VIEW_QUALITY_SITE_FLOATS, DISPLAY_VIEW_QUALITY_TAP_WORDS, DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE, assembleDisplayViewQualityLatticeWgsl, assembleDisplayViewQualityPixelsWgsl } from "./wgsl-display-view-quality-kernel.js";
+import { SDR_LUMINANCE_WEIGHTS } from "../output/sdr-rendering.js";
 /** One WGSL rounding of + − × in either direction (W3C WGSL "Floating Point Accuracy"; #471, #487): twice the binary32 unit roundoff. */
 const E = 2 * WEBGPU_F32_UNIT_ROUNDOFF;
 /** Every reported bound is doubled: the kernel's running bounds are first order, and their own float32 arithmetic rounds. */
@@ -75,37 +74,6 @@ const QUANTIZATION_SLOPE = 6.04, QUANTIZATION_JOIN_JUMP = 2.1e-4, QUANTIZATION_J
 /** Bytes per display pixel in the output buffers (moments plus the flag word). */
 const OUTPUT_BYTES_PER_PIXEL = 4 * DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS + 4 * DISPLAY_VIEW_QUALITY_FLAG_WORDS;
 const SITE_BYTES = 4 * DISPLAY_VIEW_QUALITY_SITE_FLOATS;
-/**
- * The low-signal correction states a renderer holds for one correction key, as the GPU table reads them: grid keys ascending
- * with three float32 values each (the host keeps the float64 values; the table is their single rounding).
- */
-export class CorrectionStateStore {
-    #known = new Map();
-    #keys = new Int32Array(0);
-    #values = new Float32Array(0);
-    #dirty = false;
-    get size() { return this.#known.size; }
-    has(key) { return this.#known.has(key); }
-    add(gridKeys, values) {
-        for (let i = 0; i < gridKeys.length; i++) {
-            if (this.#known.has(gridKeys[i]))
-                continue;
-            this.#known.set(gridKeys[i], [values[3 * i], values[3 * i + 1], values[3 * i + 2]]);
-            this.#dirty = true;
-        }
-    }
-    /** The sorted table (rebuilt when states were added since the last call). */
-    table() {
-        if (this.#dirty) {
-            const keys = Int32Array.from(this.#known.keys()).sort(), values = new Float32Array(3 * keys.length);
-            keys.forEach((key, i) => { const v = this.#known.get(key); values[3 * i] = v[0]; values[3 * i + 1] = v[1]; values[3 * i + 2] = v[2]; });
-            this.#keys = keys;
-            this.#values = values;
-            this.#dirty = false;
-        }
-        return { keys: this.#keys, values: this.#values };
-    }
-}
 /**
  * Waits until the queue has finished the work submitted so far (`GPUQueue.onSubmittedWorkDone`), so a pass that reads nothing
  * back is timed with its own execution, not the next pass's wait. The passes depend on each other in order anyway.
@@ -115,17 +83,6 @@ async function queueIdle(runtime, signal) {
     if (typeof queue.onSubmittedWorkDone === "function")
         await runtime.guard(queue.onSubmittedWorkDone(), signal);
 }
-/** The footprint shape of a view: real pixels per display pixel along each axis, and whether the exact area mean applies. */
-export function footprintShape(setup) {
-    const sx = setup.frameWidth / setup.viewWidth, sy = setup.frameHeight / setup.viewHeight, area = sx * sy;
-    const exact = area <= Math.min(EXACT_AREA_MEAN_MAX_PIXELS, setup.samplesPerAxis * setup.samplesPerAxis);
-    let maximumColumns = 0, maximumRows = 0;
-    for (let i = 0; i < setup.region.width; i++)
-        maximumColumns = Math.max(maximumColumns, overlaps((setup.region.x + i) * sx, (setup.region.x + i + 1) * sx, setup.frameWidth).w.length);
-    for (let j = 0; j < setup.region.height; j++)
-        maximumRows = Math.max(maximumRows, overlaps((setup.region.y + j) * sy, (setup.region.y + j + 1) * sy, setup.frameHeight).w.length);
-    return { sx, sy, exact, maximumColumns, maximumRows };
-}
 /** The demosaic candidates of a setup (the bilinear kernels when it has none) and their reach in sites. */
 function candidatesOf(setup) {
     const candidates = setup.candidates ?? setup.demosaic.map((phase) => [phase]), count = candidates[0]?.length ?? 0;
@@ -147,7 +104,7 @@ function exactLatticeConstant(c, span) {
 /**
  * Why the Quality kernels do not cover a request, or null when they do: chart materials, the exact area mean (footprints of
  * at most 25 real pixels and 6 per axis), the identity or positive Reinhard tone curve, demosaic candidates within 3 sites
- * (1 or 2 per phase), at most 64 lattice groups, lattice constants exact in float32, no collect pass, and a raster at least
+ * (1 or 2 per phase), at most 64 lattice groups, lattice constants exact in float32, and a raster at least
  * 2·reach + 2 sites on each axis (so a reflected border site lies in the band's window).
  */
 export function displayViewQualityGpuUnsupportedReason(setup, signalInput) {
@@ -157,10 +114,12 @@ export function displayViewQualityGpuUnsupportedReason(setup, signalInput) {
         return "radiance scenes (caller functions) are not on the GPU";
     if (!signalInput.kernels && !signalInput.queryPoint)
         return "the expected signal has no query points";
-    if (setup.ahdCollect)
-        return "a collect pass of the correction states runs on the CPU";
-    if (setup.toneCurve !== "identity" && setup.toneCurve !== "positive-reinhard-per-channel")
+    if (!["identity", "positive-reinhard-per-channel", "extended-reinhard-luminance", "naka-rushton-luminance"].includes(setup.toneCurve))
         return "unsupported tone curve " + String(setup.toneCurve);
+    if (setup.rendering && !setup.coupled)
+        return "the coupled rendering steps were not prepared";
+    if (setup.rendering?.highlightMode === "reconstruct-neighbors")
+        return "highlightMode reconstruct-neighbors (#602; its regions' ratios are found on the host) is not on the GPU in 2.22.0";
     if (setup.region.width < 1 || setup.region.height < 1)
         return "an empty region";
     if (signalInput.wavelengthsNm.length < 1 || signalInput.wavelengthsNm.length > DISPLAY_VIEW_QUALITY_MAXIMUM_NODES)
@@ -406,7 +365,6 @@ function constants(setup, signalInput, gather, reach, count, blocked) {
     words[9] = setup.toneCurve === "positive-reinhard-per-channel" ? 1 : 0;
     words[10] = reach;
     words[11] = count;
-    words[16] = setup.ahdCorrection ? 1 : 0;
     words[18] = gather.tapCount;
     words[19] = gather.groups.length;
     for (let c = 0; c < 3; c++)
@@ -419,7 +377,6 @@ function constants(setup, signalInput, gather, reach, count, blocked) {
     }
     floats[27] = 8.5 * 8.5;
     floats[31] = setup.clipLevel;
-    floats[35] = setup.ahdCorrection ? setup.ahdCorrection.thresholdVariance : 0;
     for (let r = 0; r < 3; r++)
         for (let c = 0; c < 3; c++)
             floats[40 + r * 3 + c] = setup.matrix[r][c];
@@ -441,10 +398,6 @@ function constants(setup, signalInput, gather, reach, count, blocked) {
     floats[52] = Math.max(FLOAT32_MINIMUM_NORMAL, Math.fround(gather.tinyMass * (1 + 4 * E)));
     return { params, words, ints, floats };
 }
-/** The reference's correction setup of a display-view setup with the AHD correction. */
-function correctionSetup(setup) {
-    return { seed: setup.seed, readout: setup.readout, gains: setup.gains, clipLevel: setup.clipLevel, matrix: setup.matrix, toneCurve: setup.toneCurve, ahdCorrection: setup.ahdCorrection };
-}
 /** How far the host's quantization term Σ(w/A)²·q(m) can move with a mean bound Δm (see QUANTIZATION_SLOPE), doubled. */
 function quantizationBound(moments, o, meanBound, pixels, step) {
     let join = 0;
@@ -462,7 +415,7 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
     if (reason)
         throw new ImageKernelExecutionError("unsupported-on-backend", "webgpu-f32 display view (Quality): " + reason + "; use cpu-reference.");
     const now = () => (typeof performance !== "undefined" ? performance.now() : Date.now());
-    const timings = { lattice: 0, sites: 0, pixels: 0, states: 0, finishing: 0, recompute: 0, pixelRedispatches: 0, siteDispatches: 0 };
+    const timings = { lattice: 0, sites: 0, pixels: 0, finishing: 0, recompute: 0, siteDispatches: 0 };
     const { region, margin } = setup, shape = footprintShape(setup), { reach, count } = candidatesOf(setup);
     // #492: the defocus disc's kernels are summed in blocks (their dense rectangles), in focus the tap list runs as before.
     const blocked = !!image || (input.blockedSum ?? (setup.gpu?.defocusRadius ?? 0) > 0);
@@ -506,19 +459,26 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
     if (gather.table.byteLength > runtime.maximumStorageBindingBytes)
         throw new ImageKernelExecutionError("insufficient-limits", "The display view's kernel table (" + gather.table.byteLength +
             " bytes: 3 channels × " + gather.tapCount + " taps × " + gather.nodes + " spectral nodes, and the material spectra) exceeds the device's storage binding limit of " + runtime.maximumStorageBindingBytes + " bytes.");
-    const largestBinding = Math.max(bandBytesOf(rows), geometry.byteLength, gather.table.byteLength, 4 * DISPLAY_VIEW_QUALITY_BITMAP_WORDS);
+    const largestBinding = Math.max(bandBytesOf(rows), geometry.byteLength, gather.table.byteLength);
     if (largestBinding > runtime.maximumStorageBindingBytes)
         throw new ImageKernelExecutionError("insufficient-limits", "One display-view band exceeds the device's storage binding limit.");
     const latticePipeline = image ? await pipelines(...image.lattice) : await pipelines("photivra-display-view-quality-lattice:" + material.id, assembleDisplayViewQualityLatticeWgsl(material.wgsl));
     const sitesPipeline = image ? await pipelines(...image.sites) : blocked ? await pipelines("photivra-display-view-quality-sites-blocked", DISPLAY_VIEW_QUALITY_SITES_BLOCKED_WGSL) :
         await pipelines("photivra-display-view-quality-sites", DISPLAY_VIEW_QUALITY_SITES_WGSL);
-    const pixelsPipeline = await pipelines("photivra-display-view-quality-pixels", DISPLAY_VIEW_QUALITY_PIXELS_WGSL);
+    // #593, #601: the coupled steps' text and constants, loaded on demand for a view that asks for them.
+    const coupled = setup.rendering ? await import("./wgsl-display-view-coupled.js") : null;
+    const coupledConstants = coupled ? coupled.displayViewCoupledConstants(setup, SDR_LUMINANCE_WEIGHTS, gaussLegendre16()) : new Float32Array(1);
+    const pixelsPipeline = coupled ? await pipelines("photivra-display-view-quality-pixels+coupled", assembleDisplayViewQualityPixelsWgsl(coupled.DISPLAY_VIEW_COUPLED_WGSL))
+        : await pipelines("photivra-display-view-quality-pixels", DISPLAY_VIEW_QUALITY_PIXELS_WGSL);
     const moments = new Float32Array(pixelCount * DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS), pixelFlags = new Uint32Array(pixelCount), masks = new Uint32Array(2 * pixelCount);
-    const states = input.states ?? new CorrectionStateStore(), correction = setup.ahdCorrection ? correctionSetup(setup) : null;
-    let statesComputed = 0, latticePointsResolved = 0;
+    let latticePointsResolved = 0;
     const scope = new GpuResourceScope(runtime);
     try {
-        const auxBuffer = scope.upload("photivra-display-view-aux", aux, BUFFER_USAGE.STORAGE);
+        // #593, #601: the coupled steps' constants follow the aux table's own entries (one zero word without them).
+        const auxWithCoupled = new Float32Array(aux.length + coupledConstants.length);
+        auxWithCoupled.set(aux);
+        auxWithCoupled.set(coupledConstants, aux.length);
+        const auxBuffer = scope.upload("photivra-display-view-aux", auxWithCoupled, BUFFER_USAGE.STORAGE);
         const geometryBuffer = scope.upload("photivra-display-view-geometry", geometry, BUFFER_USAGE.STORAGE);
         // The blocked pass reads no tap records (its layout has no binding 2).
         const tapsBuffer = blocked ? null : scope.upload("photivra-display-view-taps", gather.taps, BUFFER_USAGE.STORAGE);
@@ -611,71 +571,32 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
                 }
                 words[51] = 0;
                 timings.sites += now() - t0;
-                // Pass 3: display pixels, repeated once when a correction state was missing and has been computed.
+                // Pass 3: display pixels.
                 words[0] = count;
                 const out = band.buffer("photivra-display-view-moments", count * 4 * DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS, BUFFER_USAGE.STORAGE | BUFFER_USAGE.COPY_SRC);
                 const flagBuffer = band.buffer("photivra-display-view-flags", count * 4 * DISPLAY_VIEW_QUALITY_FLAG_WORDS, BUFFER_USAGE.STORAGE | BUFFER_USAGE.COPY_SRC);
-                const bitmapBuffer = band.buffer("photivra-display-view-bitmap", 4 * DISPLAY_VIEW_QUALITY_BITMAP_WORDS, BUFFER_USAGE.STORAGE | BUFFER_USAGE.COPY_SRC);
-                for (let attempt = 0;; attempt++) {
-                    checkAbort(abort.signal);
-                    t0 = now();
-                    const table = states.table(), stateKeys = table.keys.length > 0 ? table.keys : new Int32Array(1), stateValues = table.values.length > 0 ? table.values : new Float32Array(3);
-                    words[17] = table.keys.length;
-                    const pass = new GpuResourceScope(runtime);
-                    let data, flagData, bitmapData;
-                    try {
-                        const pixelParams = pass.upload("photivra-display-view-params-pixels", new Uint8Array(params.slice(0)), BUFFER_USAGE.UNIFORM);
-                        const keysBuffer = pass.upload("photivra-display-view-state-keys", stateKeys, BUFFER_USAGE.STORAGE);
-                        const valuesBuffer = pass.upload("photivra-display-view-state-values", stateValues, BUFFER_USAGE.STORAGE);
-                        const pixelGroup = runtime.device.createBindGroup({ layout: pixelsPipeline.getBindGroupLayout(0), entries: [
-                                { binding: 0, resource: { buffer: pixelParams } }, { binding: 1, resource: { buffer: auxBuffer } }, { binding: 2, resource: { buffer: geometryBuffer } },
-                                { binding: 3, resource: { buffer: siteBuffer } }, { binding: 4, resource: { buffer: keysBuffer } }, { binding: 5, resource: { buffer: valuesBuffer } },
-                                { binding: 6, resource: { buffer: bitmapBuffer } }, { binding: 7, resource: { buffer: out } }, { binding: 8, resource: { buffer: flagBuffer } }
-                            ] });
-                        [data, flagData, bitmapData] = await runComputePass(runtime, pass, pixelsPipeline, pixelGroup, linearDispatch(count, DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE, runtime.maximumWorkgroupsPerDimension), [{ buffer: out, bytes: count * 4 * DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS }, { buffer: flagBuffer, bytes: count * 4 * DISPLAY_VIEW_QUALITY_FLAG_WORDS }, { buffer: bitmapBuffer, bytes: 4 * DISPLAY_VIEW_QUALITY_BITMAP_WORDS }], abort.signal);
-                    }
-                    finally {
-                        pass.release();
-                    }
-                    timings.pixels += now() - t0;
-                    const flagWords = new Uint32Array(flagData, 0, count * DISPLAY_VIEW_QUALITY_FLAG_WORDS), bandFlags = new Uint32Array(count);
-                    for (let i = 0; i < count; i++)
-                        bandFlags[i] = flagWords[DISPLAY_VIEW_QUALITY_FLAG_WORDS * i];
-                    let missing = false;
-                    for (let i = 0; i < count && !missing; i++)
-                        if ((bandFlags[i] & DISPLAY_VIEW_QUALITY_FLAG.stateMissing) !== 0)
-                            missing = true;
-                    if (missing && correction && attempt === 0) {
-                        // The grid keys the band needs that the store lacks: compute them with the reference (the realm's cache serves known ones), then dispatch again.
-                        t0 = now();
-                        const bitmap = new Uint32Array(bitmapData, 0, DISPLAY_VIEW_QUALITY_BITMAP_WORDS), needed = [];
-                        for (let w = 0; w < DISPLAY_VIEW_QUALITY_BITMAP_WORDS; w++) {
-                            let bitsWord = bitmap[w];
-                            while (bitsWord !== 0) {
-                                const bit = 31 - Math.clz32(bitsWord);
-                                bitsWord &= ~(1 << bit);
-                                const key = w * 32 + bit;
-                                if (key < AHD_KEY_LEVELS ** 3 && !states.has(key))
-                                    needed.push(key);
-                            }
-                        }
-                        if (needed.length > 0) {
-                            const computed = await computeDisplayViewCorrectionStates({ ...correction, yieldControl: async () => { if (yieldControl)
-                                    await yieldControl(abort.signal); }, checkAbort: () => checkAbort(abort.signal) }, Int32Array.from(needed));
-                            states.add(computed.gridKeys, computed.values);
-                            statesComputed += needed.length;
-                        }
-                        timings.states += now() - t0;
-                        timings.pixelRedispatches++;
-                        continue;
-                    }
-                    moments.set(new Float32Array(data, 0, count * DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS), first * DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS);
-                    pixelFlags.set(bandFlags, first);
-                    for (let i = 0; i < count; i++) {
-                        masks[2 * (first + i)] = flagWords[DISPLAY_VIEW_QUALITY_FLAG_WORDS * i + 1];
-                        masks[2 * (first + i) + 1] = flagWords[DISPLAY_VIEW_QUALITY_FLAG_WORDS * i + 2];
-                    }
-                    break;
+                checkAbort(abort.signal);
+                t0 = now();
+                const pass = new GpuResourceScope(runtime);
+                let data, flagData;
+                try {
+                    const pixelParams = pass.upload("photivra-display-view-params-pixels", new Uint8Array(params.slice(0)), BUFFER_USAGE.UNIFORM);
+                    const pixelGroup = runtime.device.createBindGroup({ layout: pixelsPipeline.getBindGroupLayout(0), entries: [
+                            { binding: 0, resource: { buffer: pixelParams } }, { binding: 1, resource: { buffer: auxBuffer } }, { binding: 2, resource: { buffer: geometryBuffer } },
+                            { binding: 3, resource: { buffer: siteBuffer } }, { binding: 4, resource: { buffer: out } }, { binding: 5, resource: { buffer: flagBuffer } }
+                        ] });
+                    [data, flagData] = await runComputePass(runtime, pass, pixelsPipeline, pixelGroup, linearDispatch(count, DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE, runtime.maximumWorkgroupsPerDimension), [{ buffer: out, bytes: count * 4 * DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS }, { buffer: flagBuffer, bytes: count * 4 * DISPLAY_VIEW_QUALITY_FLAG_WORDS }], abort.signal);
+                }
+                finally {
+                    pass.release();
+                }
+                timings.pixels += now() - t0;
+                const flagWords = new Uint32Array(flagData, 0, count * DISPLAY_VIEW_QUALITY_FLAG_WORDS);
+                moments.set(new Float32Array(data, 0, count * DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS), first * DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS);
+                for (let i = 0; i < count; i++) {
+                    pixelFlags[first + i] = flagWords[DISPLAY_VIEW_QUALITY_FLAG_WORDS * i];
+                    masks[2 * (first + i)] = flagWords[DISPLAY_VIEW_QUALITY_FLAG_WORDS * i + 1];
+                    masks[2 * (first + i) + 1] = flagWords[DISPLAY_VIEW_QUALITY_FLAG_WORDS * i + 2];
                 }
             }
             finally {
@@ -698,7 +619,7 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
     const expected = new Float64Array(pixelCount * 3), noiseStd = new Float64Array(pixelCount * 3), saturated = new Float64Array(pixelCount);
     const meanBound = new Float32Array(pixelCount), varianceBound = new Float32Array(pixelCount);
     const flagged = [];
-    let largestMean = 0, largestVariance = 0, sampleCount = 0, siteCount = 0, corrected = 0;
+    let largestMean = 0, largestVariance = 0, sampleCount = 0, siteCount = 0;
     const counts = new Int32Array(geometry.buffer);
     // #533: each display pixel's saturated-pixel share from the kernel's mask (the reference's arithmetic, exact where it decided).
     const columnOverlaps = Array.from({ length: region.width }, (_, i) => overlaps((region.x + i) * shape.sx, (region.x + i + 1) * shape.sx, setup.frameWidth));
@@ -724,8 +645,6 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
             varianceBound[i] = MARGIN * moments[o + 10] + quantizationBound(moments, o, meanBound[i], pixels, step);
             largestMean = Math.max(largestMean, meanBound[i]);
             largestVariance = Math.max(largestVariance, varianceBound[i]);
-            if ((pixelFlags[i] & DISPLAY_VIEW_QUALITY_FLAG.corrected) !== 0)
-                corrected++;
             const nx = counts[rx * stride + 1];
             sampleCount += nx * ny;
             siteCount += (nx + 2 * reach) * (ny + 2 * reach);
@@ -776,7 +695,6 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
                     varianceBound[first + k] = 0;
                     recomputed.push(first + k);
                 }
-                corrected += part.ahdCorrectedPixelCount;
                 sampleCount += part.sampleCount;
                 siteCount += part.siteCount;
             });
@@ -788,10 +706,10 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
     let saturatedPixelCount = 0;
     for (let i = 0; i < pixelCount; i++)
         saturatedPixelCount += saturated[i];
-    return { samples, expected, noiseStd, sampleCount, siteCount, detailPixelCount: pixelCount, uniformPixelCount: 0, ahdCorrectedPixelCount: corrected, estimation: "exact-area-mean", saturated, saturatedPixelCount,
+    return { samples, expected, noiseStd, sampleCount, siteCount, detailPixelCount: pixelCount, uniformPixelCount: 0, estimation: "exact-area-mean", saturated, saturatedPixelCount,
         execution: webGpuExecution(expectedValueBound, uncertain), expectedValueBound, varianceBound: { kind: "relative-to-reference", relative, absolute: largestVariance },
         expectedValueAbsoluteBound: meanBound, varianceAbsoluteBound: varianceBound, flaggedPixelIndices: Uint32Array.from(flagged), hostRecomputedPixelIndices: Uint32Array.from(recomputed),
-        pixelFlags, highlightRecomputedPixelIndices: Uint32Array.from(highlights), statesComputed, statesHeld: states.size, tapsPerSite: gather.tapCount, blockedSum: blocked, siteSumRelativeBound: floats[50], latticePointsResolved, stageMilliseconds: timings };
+        pixelFlags, highlightRecomputedPixelIndices: Uint32Array.from(highlights), tapsPerSite: gather.tapCount, blockedSum: blocked, siteSumRelativeBound: floats[50], latticePointsResolved, stageMilliseconds: timings };
 }
 /**
  * The GPU setup the material modules read for a Quality render (#491's `createDisplayViewMaterialModules`). The composite module
@@ -822,19 +740,6 @@ export function qualityMaterialSetup(gpu) {
 export function qualityMaterialModule(modules, gpu, signal) {
     return modules.moduleFor(qualityMaterialSetup(gpu), signal);
 }
-/** The pixel-aperture samples per axis and anti-aliasing spots of a request. */
-export function offsetCount(request) { return request.boxSamples * request.boxSamples * (request.antiAliasing ? 4 : 1); }
-/**
- * Why the Quality renderer does not support a prepared request (`DisplayViewGpuRenderer.supports`), or true: engine charts and
- * declared `material-layers` scenes (the material modules of `createDisplayViewMaterialModules`, #491), the identity or Reinhard
- * tone curve and at most 64 query offsets (lattice groups). `lens.defocus` out of focus is supported (#492 step 2c: the site pass
- * gathers the disc, or each node's diffraction kernel convolved with it, up to the reference's own caps of radius 64 and 96);
- * whether a view's footprints take the exact area mean, whether the device passes the composite probe, and whether the kernel
- * table fits the device's storage binding limit, is known only per render.
- */
-export function displayViewQualityGpuSupports(request) {
-    return sceneToneAndOffsetsReason(request, MAXIMUM_GROUPS);
-}
 /** A normalized, symmetric site kernel of radius R for the self-check (a binned Gaussian of width `sigma` sites). */
 function syntheticKernel(radius, sigma) {
     const size = 2 * radius + 1, kernel = new Float64Array(size * size);
@@ -855,8 +760,7 @@ function syntheticKernel(radius, sigma) {
  * the GPU against `renderDisplayView` within the a-priori bounds, every flagged pixel recomputed:
  *
  * - `display-view:quality:checkerboard-13x9-diffraction-ahd` (#479): synthetic radius-1 diffraction kernels at three spectral
- *   nodes, the AHD candidates and the low-signal correction (few electrons per site, so the correction applies; 64 draws per
- *   state keep the check short), the tap-list site pass;
+ *   nodes, the AHD candidates at few electrons per site, the tap-list site pass;
  * - `display-view:quality:checkerboard-13x9-defocus-blocked` (#492): the engine's own defocus disc of 6.3 sites (radius 3) at
  *   every node, the bilinear demosaic (a defocused Speed request's route), the blocked site sum, and a tap budget that splits
  *   each band's site pass over several dispatches.
@@ -872,13 +776,11 @@ async function runQualityConformance(handle, signal, defocus) {
     const signalInput = { nativeWidth, nativeHeight, outputWidth: frameWidth, wavelengthsNm: nodes, electronsPerRadiance: conformanceResponses(defocus ? 1 : 0.1),
         offsets, kernels, scene, channelAt: conformanceChannelAt };
     const setup = conformanceSetup(signalInput, { perElectron: defocus ? 1 / 40000 : 1 / 4000, darkElectrons: 0.07, constantVariance: 2.5e-7 }, 479, 5 + (disc ? disc.radius : 0), signal, defocus ? {} : { candidates: [0, 1, 2, 3].map((p) => ahdCandidateKernels(p % 2, Math.floor(p / 2))),
-        ahdCorrection: { labMatrix: [[0.4124, 0.3576, 0.1805], [0.2126, 0.7152, 0.0722], [0.0193, 0.1192, 0.9505]].map((row) => row.map((v, c) => v * [1.1, 1, 1.6][c])), drawsPerState: 64, thresholdVariance: 1e-4 } });
+        ahdChoice: { labMatrix: [[0.4124, 0.3576, 0.1805], [0.2126, 0.7152, 0.0722], [0.0193, 0.1192, 0.9505]].map((row) => row.map((v, c) => v * [1.1, 1, 1.6][c])) } });
     const reference = await renderDisplayView(setup);
     return await withConformanceAbort(runtime, signal, async (abort, pipelines) => {
         const gather = defocus ? { blockedSum: true, maximumSiteTapsPerDispatch: 64 * 4 * (2 * 3 + 2) ** 2 } : {};
         const gpu = await renderDisplayViewQualityOnGpu(runtime, 1 << 20, { setup, signalInput, material: chartPresetMaterialModule(chart), ...gather }, abort, undefined, pipelines);
-        if (!defocus && (gpu.ahdCorrectedPixelCount === 0 || reference.ahdCorrectedPixelCount === 0))
-            return "the self-check did not exercise the low-signal correction.";
         if (defocus && (!gpu.blockedSum || gpu.stageMilliseconds.siteDispatches < 2))
             return "the self-check did not exercise the blocked site sum over several dispatches.";
         // #533: the verdict includes the saturated-pixel count (the light squares sit at the white clip).
@@ -891,97 +793,6 @@ export const DISPLAY_VIEW_QUALITY_CONFORMANCE_CASE = { id: "display-view:quality
 /** #492's self-check of the defocus disc's blocked site sum (see `runQualityConformance`). */
 export const DISPLAY_VIEW_QUALITY_DEFOCUS_CONFORMANCE_CASE = { id: "display-view:quality:checkerboard-13x9-defocus-blocked",
     run: (handle, signal) => runQualityConformance(handle, signal, true) };
-/** The bilinear RGGB demosaic kernels per phase (phaseY·2 + phaseX) and channel, as `bilinearPhaseProfiles` gives them. */
-export function bilinearKernels() {
-    const cross = [[1, 0], [-1, 0], [0, 1], [0, -1]], diagonal = [[1, 1], [1, -1], [-1, 1], [-1, -1]], horizontal = [[1, 0], [-1, 0]], vertical = [[0, 1], [0, -1]];
-    const average = (offsets) => offsets.map(([dx, dy]) => ({ dx: dx, dy: dy, weight: 1 / offsets.length })), self = [{ dx: 0, dy: 0, weight: 1 }];
-    return [[self, average(cross), average(diagonal)], [average(horizontal), self, average(vertical)], [average(vertical), self, average(horizontal)], [average(diagonal), average(cross), self]];
-}
-/**
- * The display view's GPU renderer on one runtime (#481's `DisplayViewGpuRenderer`): the Speed kernel for requests it covers
- * (no diffraction, no AHD, no defocus disc, at most 16 offsets) and the Quality kernels for the rest (#492: a defocused Speed
- * request too, with its bilinear demosaic). One pipeline cache per device, one set of
- * material modules (#491: chart presets, composite charts, the 2.3 elements and material-layers scenes; `dispose` releases their
- * uploaded scene records), one correction-state store per correction key. `render` renders the part's region (`setup.gpu`
- * carries the expected signal's input and the chart; a setup without it, a coarse view or a frame the kernels do not cover
- * throws `unsupported-on-backend`), and throws `aborted` and `device-lost` as the accelerator's operations do.
- */
-/** #564: the GPU refusal of a defocus kernel above the direct radius (the CPU convolves it by runs). */
-const LARGE_DEFOCUS_REASON = "a defocus kernel radius above 64 sites (convolved by runs on the CPU, #564) is not on the GPU";
-export function createDisplayViewGpuRenderer(runtime, options = {}) {
-    const pipelines = new Map(), stores = new Map();
-    const bandBytes = options.maximumBandBytes ?? Math.min(64 * 1024 * 1024, runtime.maximumStorageBindingBytes);
-    const source = (label, code) => {
-        let pending = pipelines.get(label);
-        if (!pending) {
-            pending = createComputePipeline(runtime, label, code, undefined);
-            pipelines.set(label, pending);
-            pending.catch(() => pipelines.delete(label));
-        }
-        return pending;
-    };
-    // #491: one set of material modules per device for both kernels (the preset module per chart; the composite module, its probe
-    // and its uploaded scene records), released by `dispose`.
-    const modules = createDisplayViewMaterialModules(runtime, source);
-    return {
-        id: "photivra-display-view",
-        supports(request) {
-            if (request.largeDefocus)
-                return LARGE_DEFOCUS_REASON;
-            // #492: out of focus the expected signal carries the defocus disc as site kernels, which only the Quality site pass gathers;
-            // a Speed request then runs the Quality passes with its own bilinear demosaic (one candidate) and finishing.
-            if (request.defocus)
-                return displayViewQualityGpuSupports(request);
-            const speed = displayViewSpeedGpuSupports(request);
-            if (speed === true)
-                return true;
-            return displayViewQualityGpuSupports(request);
-        },
-        conformanceCases: [DISPLAY_VIEW_SPEED_CONFORMANCE_CASE, DISPLAY_VIEW_QUALITY_CONFORMANCE_CASE, DISPLAY_VIEW_QUALITY_DEFOCUS_CONFORMANCE_CASE],
-        async render(part) {
-            const { setup, signal } = part;
-            if (!setup.gpu)
-                throw new ImageKernelExecutionError("unsupported-on-backend", "The display-view setup carries no GPU inputs (setup.gpu); use cpu-reference.");
-            const abort = new AbortController(), onAbort = () => abort.abort();
-            if (signal?.aborted)
-                throw abortedError();
-            signal?.addEventListener("abort", onAbort, { once: true });
-            try {
-                const signalInput = setup.gpu.signalInput;
-                let result;
-                let material;
-                if (displayViewSpeedGpuUnsupportedReason(setup, signalInput) === null) {
-                    material = await modules.moduleFor(setup.gpu, abort.signal);
-                    result = await renderDisplayViewSpeedOnGpu(runtime, bandBytes, { setup, signalInput, material }, abort, options.yieldControl, source);
-                }
-                else {
-                    // #581: an image-plane print brings its own passes 1 and 2.
-                    const image = signalInput.scene.image ? await modules.imagePasses(setup.gpu, abort.signal) : undefined;
-                    material = image ? { id: "image-plane", wgsl: "", bindings: [] } : await qualityMaterialModule(modules, setup.gpu, abort.signal);
-                    const key = displayViewCorrectionKey(setup);
-                    let states = key === null ? undefined : stores.get(key);
-                    if (key !== null && !states) {
-                        states = new CorrectionStateStore();
-                        stores.set(key, states);
-                    }
-                    result = await renderDisplayViewQualityOnGpu(runtime, bandBytes, { setup, signalInput, material, ...(image ? { image } : {}), ...(states ? { states } : {}) }, abort, options.yieldControl, source);
-                }
-                return { samples: result.samples, expected: result.expected, noiseStd: result.noiseStd, sampleCount: result.sampleCount, siteCount: result.siteCount, detailPixelCount: result.detailPixelCount,
-                    uniformPixelCount: result.uniformPixelCount, ahdCorrectedPixelCount: result.ahdCorrectedPixelCount, estimation: result.estimation, saturated: result.saturated,
-                    saturatedPixelCount: result.saturatedPixelCount, errorBound: result.expectedValueBound,
-                    diagnosticUncertaintySampleCount: result.execution.diagnosticUncertaintySampleCount, ...(material.compositeProbe ? { compositeProbe: material.compositeProbe } : {}) };
-            }
-            finally {
-                signal?.removeEventListener("abort", onAbort);
-            }
-        },
-        dispose() { modules.release(); stores.clear(); }
-    };
-}
-/** The factory `prepareDisplayView` creates the renderer with (one per device): the Speed and Quality kernels behind one renderer. */
-export const displayViewGpuRendererFactory = (handle) => createDisplayViewGpuRenderer(handle);
-/** Registers the combined renderer as the display view's GPU renderer and returns the factory registered before. */
-export function registerDisplayViewGpuRenderer() {
-    return setDisplayViewGpuRendererFactory(displayViewGpuRendererFactory);
-}
+/** #594: the Quality kernels' self-check cases, run before the first render that takes the Quality passes (`onDemandConformanceCases`). */
+export const DISPLAY_VIEW_QUALITY_CONFORMANCE_CASES = Object.freeze([DISPLAY_VIEW_QUALITY_CONFORMANCE_CASE, DISPLAY_VIEW_QUALITY_DEFOCUS_CONFORMANCE_CASE]);
 //# sourceMappingURL=display-view-quality-gpu.js.map