@photivra/engine 2.20.0 → 2.22.0

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,26 +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, createDisplayViewExpectedSignal, 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 { resolvePortableChartScene } from "../facade/chart-scenes.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, 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_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. */
@@ -62,7 +60,7 @@ export const DISPLAY_VIEW_QUALITY_MAXIMUM_KERNEL_RADIUS = 96;
  * several invocations per site is needed.
  */
 export const DISPLAY_VIEW_QUALITY_SITE_TAPS_PER_DISPATCH = 2 ** 30;
-/** The smallest positive normal float32: table values below it may be flushed to zero by a device (WGSL allows it). */
+/** The smallest positive normal float32: values below it may be flushed to zero by a device (WGSL allows it). */
 const FLOAT32_MINIMUM_NORMAL = 2 ** -126;
 /** Candidate table entries per phase: the (2·reach + 1)² window. */
 const WINDOW_SLOTS = (2 * MAXIMUM_REACH + 1) ** 2;
@@ -76,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.
@@ -116,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;
@@ -148,22 +104,26 @@ 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) {
     if (signalInput.largeKernel)
         return LARGE_DEFOCUS_REASON;
-    if (signalInput.scene.kind !== "materials")
+    if (signalInput.scene.kind !== "materials" && !signalInput.scene.image)
         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)
+        return "the site passes integrate 1 to " + DISPLAY_VIEW_QUALITY_MAXIMUM_NODES + " spectral nodes per site";
     if (signalInput.kernels && (signalInput.kernels.radius < 0 || signalInput.kernels.radius > DISPLAY_VIEW_QUALITY_MAXIMUM_KERNEL_RADIUS))
         return "a site kernel radius above " + DISPLAY_VIEW_QUALITY_MAXIMUM_KERNEL_RADIUS + " (the diffraction and defocus caps)";
     const shape = footprintShape(setup);
@@ -209,9 +169,9 @@ export function displayViewQualityGpuUnsupportedReason(setup, signalInput) {
     }
     return null;
 }
-function signalGather(signalInput, factored) {
-    const tables = displayViewSignalTables(signalInput), scene = signalInput.scene;
-    const W = signalInput.nativeWidth, H = signalInput.nativeHeight, R = signalInput.kernels ? signalInput.kernels.radius : 0, materials = scene.materials.length;
+function signalGather(signalInput) {
+    const tables = displayViewSignalTables(signalInput), A = signalInput.electronsPerRadiance, N = signalInput.wavelengthsNm.length, spectra = tables.spectra;
+    const W = signalInput.nativeWidth, H = signalInput.nativeHeight, R = signalInput.kernels ? signalInput.kernels.radius : 0, materials = spectra.length;
     // Taps in order: per group, with site kernels the dense rectangle row-major (tap (dx, dy) reads lattice offset (minIx − R + dx,
     // minIy − R + dy)), without them one tap per member. Plain loops: a radius-96 kernel has up to 150 544 taps.
     const tapGroup = [], tapDp = [], tapDq = [], tapIndex = [];
@@ -239,7 +199,6 @@ function signalGather(signalInput, factored) {
         groups.push({ dpMin, dqMin, dpSpan: dpMax - dpMin, dqSpan: dqMax - dqMin, cu: 0.5 + group.fx - W / 2, cv: 0.5 + group.fy - H / 2, firstTap: first,
             cw: signalInput.kernels ? group.cw : 0, ch: signalInput.kernels ? group.ch : 0 });
     });
-    const direct = (m, c) => { const si = tables.spectralIndex[m]; return si < 0 ? tables.reflectance[m] * tables.neutralDirect[c] : tables.spectralDirect[c][si]; };
     const T = tapGroup.length, taps = new Uint32Array(T * DISPLAY_VIEW_QUALITY_TAP_WORDS), spread = new Float32Array(3 * T);
     for (let t = 0; t < T; t++) {
         const g = tapGroup[t], group = groups[g];
@@ -247,91 +206,64 @@ function signalGather(signalInput, factored) {
         taps[t * DISPLAY_VIEW_QUALITY_TAP_WORDS + 1] = tapDp[t] - group.dpMin;
         taps[t * DISPLAY_VIEW_QUALITY_TAP_WORDS + 2] = tapDq[t] - group.dqMin;
     }
-    const check = (value) => {
-        if (!(Math.abs(value) <= FLOAT32_SAFE_MAGNITUDE))
-            throw new ImageKernelExecutionError("unsupported-float32-domain", "A material's channel signal exceeds the float32 domain.");
-        return value;
-    };
-    const tiny = new Float64Array(T);
-    if (factored && signalInput.kernels) {
-        // #492: one neutral row (the white's combined kernel, which the reference scales by each neutral material's reflectance) and one
-        // row per spectral material; the spread of a tap over the materials from the neutral reflectances' range and the spectral rows.
-        const spectralCount = tables.spectral.length, rows = 1 + spectralCount, table = new Float32Array(rows * 3 * T), materialRows = new Uint32Array(2 * materials);
-        const reflectanceBits = new Float32Array(materialRows.buffer);
-        let neutralLow = Infinity, neutralHigh = -Infinity, neutralSmallest = Infinity;
-        for (let m = 0; m < materials; m++) {
-            const si = tables.spectralIndex[m];
-            if (si < 0) {
-                const r = check(tables.reflectance[m]);
-                materialRows[2 * m] = 0;
-                reflectanceBits[2 * m + 1] = r;
-                neutralLow = Math.min(neutralLow, r);
-                neutralHigh = Math.max(neutralHigh, r);
-                if (r > 0)
-                    neutralSmallest = Math.min(neutralSmallest, r);
-            }
-            else {
-                materialRows[2 * m] = 1 + si;
-                reflectanceBits[2 * m + 1] = 1;
-            }
+    // Every value finite and non-negative, every spectrum value normal (a device may flush the others) and every sum in range.
+    const domain = () => { throw new ImageKernelExecutionError("unsupported-float32-domain", "A site's spectral terms are outside the float32 domain."); };
+    // The spectra and their envelope per node.
+    const base = 3 * T * N, table = new Float32Array(base + materials * N), low = new Float64Array(N).fill(Infinity), high = new Float64Array(N).fill(-Infinity);
+    let smallestL = Infinity;
+    spectra.forEach((L, m) => {
+        for (let n = 0; n < N; n++) {
+            const l = L[n];
+            if (!(l >= 0 && l <= FLOAT32_SAFE_MAGNITUDE))
+                domain();
+            table[base + m * N + n] = l;
+            low[n] = Math.min(low[n], l);
+            high[n] = Math.max(high[n], l);
+            if (l > 0)
+                smallestL = Math.min(smallestL, l);
         }
-        for (let t = 0; t < T; t++) {
-            const source = tables.groups[tapGroup[t]], index = tapIndex[t];
-            for (let c = 0; c < 3; c++) {
-                let low = Infinity, high = -Infinity;
-                const white = check(source.neutral[c][index]);
-                table[c * T + t] = white;
-                if (neutralHigh >= neutralLow) {
-                    low = neutralLow * white;
-                    high = neutralHigh * white;
-                    // A neutral term r·N below the float32 normal range may be flushed: at most min(r_max·N, 2⁻¹²⁶).
-                    if (neutralSmallest * white < FLOAT32_MINIMUM_NORMAL && white > 0)
-                        tiny[t] = Math.max(tiny[t], Math.min(neutralHigh * white, FLOAT32_MINIMUM_NORMAL));
-                }
-                for (let si = 0; si < spectralCount; si++) {
-                    const value = check(source.spectral[c][si][index]);
-                    table[((1 + si) * 3 + c) * T + t] = value;
-                    low = Math.min(low, value);
-                    high = Math.max(high, value);
-                    if (value > 0 && value < FLOAT32_MINIMUM_NORMAL)
-                        tiny[t] = Math.max(tiny[t], value);
-                }
-                spread[c * T + t] = Math.fround((high - low) * (1 + 4 * E));
-            }
-        }
-        let tinyMass = 0;
-        for (let t = 0; t < T; t++)
-            tinyMass += tiny[t];
-        return { groups, taps, tapCount: T, table, materialRows, spread, materials, tinyMass };
-    }
-    const table = new Float32Array(materials * 3 * T);
+    });
+    if (smallestL < FLOAT32_MINIMUM_NORMAL)
+        domain();
+    let largestSum = 0, tinyMass = (T + 2) * N * FLOAT32_MINIMUM_NORMAL;
     for (let t = 0; t < T; t++) {
         const source = tables.groups[tapGroup[t]], index = tapIndex[t];
+        let tiny = 0;
         for (let c = 0; c < 3; c++) {
-            let low = Infinity, high = -Infinity;
-            for (let m = 0; m < materials; m++) {
-                const si = tables.spectralIndex[m];
-                const value = check(signalInput.kernels ? (si < 0 ? tables.reflectance[m] * source.neutral[c][index] : source.spectral[c][si][index]) : source.members[index].weight * direct(m, c));
-                table[(m * 3 + c) * T + t] = value;
-                low = Math.min(low, value);
-                high = Math.max(high, value);
-                if (value > 0 && value < FLOAT32_MINIMUM_NORMAL)
-                    tiny[t] = Math.max(tiny[t], value);
+            let range = 0, mass = 0, tinyHere = 0;
+            for (let n = 0; n < N; n++) {
+                const value = signalInput.kernels ? source.nodeKernels[c][index * N + n] : source.members[index].weight * A[c][n];
+                if (!(value >= 0 && value <= FLOAT32_SAFE_MAGNITUDE))
+                    domain();
+                table[(c * T + t) * N + n] = value;
+                if (materials > 0) {
+                    const top = value * high[n];
+                    range += value * (high[n] - low[n]);
+                    mass += top;
+                    // A kernel value or product below the normal range may be flushed: at most the product with the largest spectrum.
+                    if (value > 0 && (value < FLOAT32_MINIMUM_NORMAL || top < 2 * FLOAT32_MINIMUM_NORMAL))
+                        tinyHere += top;
+                }
             }
-            // The spread rounded up (a float32 rounding of the two values and of the difference).
-            spread[c * T + t] = Math.fround((high - low) * (1 + 4 * E));
+            // The spread rounded up (the float32 roundings of the operands, the products and the sum).
+            spread[c * T + t] = Math.fround(range * (1 + (N + 4) * E));
+            largestSum = Math.max(largestSum, mass);
+            tiny = Math.max(tiny, tinyHere);
         }
+        tinyMass += tiny;
     }
-    let tinyMass = 0;
-    for (let t = 0; t < T; t++)
-        tinyMass += tiny[t];
-    return { groups, taps, tapCount: T, table, materialRows: null, spread, materials, tinyMass };
+    if (!(largestSum * T <= FLOAT32_SAFE_MAGNITUDE))
+        domain();
+    return { groups, taps, tapCount: T, nodes: N, table, spread, materials, tinyMass };
 }
 /**
  * The relative bound of a site's electrons (`params.site_gamma`): (T + 3)·E for the tap-list sum (#479), and with the blocked sum
- * (#492) (cw_max + ch_max + G + 3)·E: a term carries two host roundings (u = E/2 each: its row value and the reflectance), the
- * product (E), at most cw additions in its row, ch in its group and G in the total, and the dark electrons' addition, all of
- * non-negative terms (docs/WEBGPU.md).
+ * (#492) (cw_max + ch_max + G + 3)·E, both unchanged by 2.21.0. Every term C_c(t, n)·L_m(λ_n) is non-negative and carries two host
+ * roundings (u = E/2 each: the kernel value and the spectrum) and its product (E); the tap-list pass adds it into its node's
+ * partial over the T taps (at most T − 1 inexact additions), the blocked pass into a row, group and total partial per node (at
+ * most cw − 1 + ch − 1 + G − 1). The N node partials and the dark electrons (host-rounded, E/2) are then summed in integer
+ * arithmetic and rounded once (E, `EXACT_SUM_WGSL`). So a site carries at most (T + 2.5)·E, or (cw + ch + G + 0.5)·E, inside the
+ * bounds (docs/WEBGPU.md).
  */
 function siteSumRelativeBound(gather, blocked) {
     if (!blocked)
@@ -406,8 +338,7 @@ function resolveUncertainLattice(lattice, groupWords, signalInput) {
             if ((raw >>> 31) === 0)
                 continue;
             const p = lx0 + (local % lw), q = ly0 + Math.floor(local / lw);
-            const u = group.fx === 0 ? (p + 0.5 - W / 2) * g : (p + 0.5 + group.fx - W / 2) * g, v = group.fy === 0 ? -(q + 0.5 - H / 2) * g : -(q + 0.5 + group.fy - H / 2) * g;
-            const m = scene.materialAt(u, v);
+            const m = scene.materialAt(latticeCoordinate(p, group.fx, W, g), -latticeCoordinate(q, group.fy, H, g));
             if (!(Number.isInteger(m) && m >= 0 && m < scene.materials.length))
                 throw new ImageKernelExecutionError("unsupported-on-backend", "webgpu-f32 display view (Quality): a lattice point has no scene material; use cpu-reference.");
             lattice[first + local] = m;
@@ -416,6 +347,11 @@ function resolveUncertainLattice(lattice, groupWords, signalInput) {
     });
     return resolved;
 }
+/**
+ * One axis of the reference's lattice point (createDisplayViewExpectedSignal's latticeU / latticeV, written as it writes them):
+ * (i + 0.5 − size/2)·g with no shift, (i + 0.5 + f − size/2)·g otherwise; v is its negative.
+ */
+export const latticeCoordinate = (i, f, size, g) => (f === 0 ? i + 0.5 - size / 2 : i + 0.5 + f - size / 2) * g;
 /** The uniform parameters shared by the three passes (per-pass words are set per dispatch). */
 function constants(setup, signalInput, gather, reach, count, blocked) {
     const params = new ArrayBuffer(4 * DISPLAY_VIEW_QUALITY_PARAM_WORDS), words = new Uint32Array(params), ints = new Int32Array(params), floats = new Float32Array(params);
@@ -429,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++)
@@ -442,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];
@@ -458,15 +392,12 @@ function constants(setup, signalInput, gather, reach, count, blocked) {
         floats[49] = geometry.scaleV;
     }
     floats[50] = siteSumRelativeBound(gather, blocked);
-    // #492: the table values a device may flush to zero (blocked sum only), rounded up and kept normal so the uniform is not flushed either.
-    if (blocked && gather.tinyMass > 0)
-        floats[52] = Math.max(FLOAT32_MINIMUM_NORMAL, Math.fround(gather.tinyMass * (1 + 4 * E)));
+    // 2.21.0: the spectral nodes the site passes integrate.
+    words[53] = gather.nodes;
+    // What a flushing device can drop (both site passes), rounded up and kept normal so the uniform is not flushed either.
+    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;
@@ -479,19 +410,24 @@ function quantizationBound(moments, o, meanBound, pixels, step) {
 }
 /** Renders one region of a Quality display view on the GPU (see the module comment). */
 export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, abort, yieldControl, pipelines) {
-    const { setup, signalInput, material } = input;
+    const { setup, signalInput, material, image } = input;
     const reason = displayViewQualityGpuUnsupportedReason(setup, signalInput);
     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 = input.blockedSum ?? (setup.gpu?.defocusRadius ?? 0) > 0;
-    if (blocked && !signalInput.kernels)
+    const blocked = !!image || (input.blockedSum ?? (setup.gpu?.defocusRadius ?? 0) > 0);
+    if (blocked && !signalInput.kernels && !image)
         throw new ImageKernelExecutionError("unsupported-on-backend", "webgpu-f32 display view (Quality): the blocked site sum needs site kernels; use cpu-reference.");
     const tapBudget = input.maximumSiteTapsPerDispatch ?? DISPLAY_VIEW_QUALITY_SITE_TAPS_PER_DISPATCH;
-    const gather = signalGather(signalInput, blocked), aux = auxTable(setup), { params, words, ints, floats } = constants(setup, signalInput, gather, reach, count, blocked);
+    const gather = image?.gather ?? signalGather(signalInput), aux = auxTable(setup), { params, words, ints, floats } = constants(setup, signalInput, gather, reach, count, blocked);
+    // #581: the print's site bound and its radiance values per lattice point (the site pass's node count in the last word).
+    if (image) {
+        floats[50] = image.siteGamma;
+        words[55] = image.pointFloats;
+    }
     const stride = DISPLAY_VIEW_QUALITY_GEOMETRY_STRIDE, geometry = new Float32Array((region.width + region.height) * stride);
     const columnSums = [], rowSums = [];
     for (let i = 0; i < region.width; i++) {
@@ -512,7 +448,7 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
         const { y0, y1 } = siteRows(0, rows), siteH = y1 - y0 + 1;
         let lattice = 0;
         for (const g of gather.groups)
-            lattice += (siteW + g.dpSpan) * (siteH + g.dqSpan) * 4;
+            lattice += (siteW + g.dpSpan) * (siteH + g.dqSpan) * 4 * (image ? image.pointFloats + 1 : 1);
         return lattice + siteW * siteH * SITE_BYTES + rows * region.width * OUTPUT_BYTES_PER_PIXEL;
     };
     let rows = region.height;
@@ -521,32 +457,36 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
     // The value table (materials × 3 channels × taps) is one binding: with a large defocus kernel and many materials it can pass the
     // device's limit, which is then refused by name (never clipped).
     if (gather.table.byteLength > runtime.maximumStorageBindingBytes)
-        throw new ImageKernelExecutionError("insufficient-limits", "The display view's kernel table (" +
-            (gather.materialRows ? gather.table.length / (3 * gather.tapCount) + " rows (the neutral white and each spectral material)" : gather.materials + " materials") + " × 3 channels × " +
-            gather.tapCount + " taps per site, " + gather.table.byteLength + " bytes) 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);
+        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);
     if (largestBinding > runtime.maximumStorageBindingBytes)
         throw new ImageKernelExecutionError("insufficient-limits", "One display-view band exceeds the device's storage binding limit.");
-    const latticePipeline = await pipelines("photivra-display-view-quality-lattice:" + material.id, assembleDisplayViewQualityLatticeWgsl(material.wgsl));
-    const sitesPipeline = blocked ? await pipelines("photivra-display-view-quality-sites-blocked", DISPLAY_VIEW_QUALITY_SITES_BLOCKED_WGSL) :
+    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);
         const tableBuffer = scope.upload("photivra-display-view-table", gather.table, BUFFER_USAGE.STORAGE);
         const spreadBuffer = scope.upload("photivra-display-view-spread", gather.spread, BUFFER_USAGE.STORAGE);
-        const materialRowsBuffer = gather.materialRows ? scope.upload("photivra-display-view-material-rows", gather.materialRows, BUFFER_USAGE.STORAGE) : null;
         // A module's binding is data uploaded per render or a buffer the module already holds on the device (#491: scene records).
-        const materialEntries = material.bindings.map((b) => ({ binding: b.binding, resource: { buffer: b.buffer ??
-                    scope.upload("photivra-display-view-material-" + b.binding, b.data, b.kind === "uniform" ? BUFFER_USAGE.UNIFORM : BUFFER_USAGE.STORAGE) } }));
-        const materialGroup = runtime.device.createBindGroup({ layout: latticePipeline.getBindGroupLayout(1), entries: materialEntries });
+        const materialGroup = image ? null : runtime.device.createBindGroup({ layout: latticePipeline.getBindGroupLayout(1), entries: material.bindings.map((b) => ({ binding: b.binding, resource: { buffer: b.buffer ??
+                        scope.upload("photivra-display-view-material-" + b.binding, b.data, b.kind === "uniform" ? BUFFER_USAGE.UNIFORM : BUFFER_USAGE.STORAGE) } })) });
         const gate = createHostYieldGate();
         for (let row0 = 0; row0 < region.height; row0 += rows) {
             checkAbort(abort.signal);
@@ -576,26 +516,35 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
             const band = new GpuResourceScope(runtime);
             try {
                 const groupBuffer = band.upload("photivra-display-view-groups", groupWords, BUFFER_USAGE.STORAGE);
-                let latticeBuffer = band.buffer("photivra-display-view-lattice", latticeTotal * 4, BUFFER_USAGE.STORAGE | (blocked ? BUFFER_USAGE.COPY_SRC : 0));
                 const siteBuffer = band.buffer("photivra-display-view-sites", siteW * siteH * SITE_BYTES, BUFFER_USAGE.STORAGE);
-                // Pass 1: lattice materials.
+                // Pass 1: lattice materials (#581: an image-plane print's radiance per node, with its flags, and their host resolution).
                 let t0 = now();
                 words[0] = latticeTotal;
                 const latticeParams = band.upload("photivra-display-view-params-lattice", new Uint8Array(params.slice(0)), BUFFER_USAGE.UNIFORM);
-                const latticeGroup = runtime.device.createBindGroup({ layout: latticePipeline.getBindGroupLayout(0), entries: [
-                        { binding: 0, resource: { buffer: latticeParams } }, { binding: 1, resource: { buffer: groupBuffer } }, { binding: 2, resource: { buffer: latticeBuffer } }
-                    ] });
-                const [latticeData] = await runComputePass(runtime, band, latticePipeline, [latticeGroup, materialGroup], linearDispatch(latticeTotal, DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE, runtime.maximumWorkgroupsPerDimension), blocked ? [{ buffer: latticeBuffer, bytes: latticeTotal * 4 }] : [], abort.signal);
-                await queueIdle(runtime, abort.signal);
-                if (blocked) {
-                    // #492: with a wide disc nearly every site reads some uncertain lattice point, and its spread over every material would flag
-                    // it. The host resolves each uncertain point with the reference's own material lookup at the reference's lattice point
-                    // (createDisplayViewExpectedSignal's latticeU/latticeV), so the sites read exactly the reference's materials.
-                    const lattice = new Uint32Array(latticeData, 0, latticeTotal);
-                    const resolved = resolveUncertainLattice(lattice, groupWords, signalInput);
-                    if (resolved > 0)
-                        latticeBuffer = band.upload("photivra-display-view-lattice-resolved", lattice, BUFFER_USAGE.STORAGE);
-                    latticePointsResolved += resolved;
+                let latticeBuffer, pointFlags = null;
+                if (image) {
+                    const pass = await image.runLattice(band, latticePipeline, latticeParams, groupBuffer, groupWords, latticeTotal, abort.signal);
+                    latticeBuffer = pass.values;
+                    pointFlags = pass.flags;
+                    latticePointsResolved += pass.resolved;
+                }
+                else {
+                    latticeBuffer = band.buffer("photivra-display-view-lattice", latticeTotal * 4, BUFFER_USAGE.STORAGE | (blocked ? BUFFER_USAGE.COPY_SRC : 0));
+                    const latticeGroup = runtime.device.createBindGroup({ layout: latticePipeline.getBindGroupLayout(0), entries: [
+                            { binding: 0, resource: { buffer: latticeParams } }, { binding: 1, resource: { buffer: groupBuffer } }, { binding: 2, resource: { buffer: latticeBuffer } }
+                        ] });
+                    const [latticeData] = await runComputePass(runtime, band, latticePipeline, [latticeGroup, materialGroup], linearDispatch(latticeTotal, DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE, runtime.maximumWorkgroupsPerDimension), blocked ? [{ buffer: latticeBuffer, bytes: latticeTotal * 4 }] : [], abort.signal);
+                    await queueIdle(runtime, abort.signal);
+                    if (blocked) {
+                        // #492: with a wide disc nearly every site reads some uncertain lattice point, and its spread over every material would flag
+                        // it. The host resolves each uncertain point with the reference's own material lookup at the reference's lattice point
+                        // (createDisplayViewExpectedSignal's latticeU/latticeV), so the sites read exactly the reference's materials.
+                        const lattice = new Uint32Array(latticeData, 0, latticeTotal);
+                        const resolved = resolveUncertainLattice(lattice, groupWords, signalInput);
+                        if (resolved > 0)
+                            latticeBuffer = band.upload("photivra-display-view-lattice-resolved", lattice, BUFFER_USAGE.STORAGE);
+                        latticePointsResolved += resolved;
+                    }
                 }
                 timings.lattice += now() - t0;
                 // Pass 2: site moments, in chunks of whole workgroups of sites whose taps stay within the budget per dispatch (#492).
@@ -610,8 +559,7 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
                         const siteParams = chunk.upload("photivra-display-view-params-sites", new Uint8Array(params.slice(0)), BUFFER_USAGE.UNIFORM);
                         const siteGroup = runtime.device.createBindGroup({ layout: sitesPipeline.getBindGroupLayout(0), entries: [
                                 { binding: 0, resource: { buffer: siteParams } }, { binding: 1, resource: { buffer: groupBuffer } }, ...(tapsBuffer ? [{ binding: 2, resource: { buffer: tapsBuffer } }] : []),
-                                { binding: 3, resource: { buffer: tableBuffer } }, { binding: 4, resource: { buffer: latticeBuffer } }, { binding: 5, resource: { buffer: siteBuffer } }, { binding: 6, resource: { buffer: spreadBuffer } },
-                                ...(materialRowsBuffer ? [{ binding: 7, resource: { buffer: materialRowsBuffer } }] : [])
+                                { binding: 3, resource: { buffer: tableBuffer } }, { binding: 4, resource: { buffer: latticeBuffer } }, { binding: 5, resource: { buffer: siteBuffer } }, { binding: 6, resource: { buffer: pointFlags ?? spreadBuffer } },
                             ] });
                         await runComputePass(runtime, chunk, sitesPipeline, siteGroup, linearDispatch(words[0], DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE, runtime.maximumWorkgroupsPerDimension), [], abort.signal);
                         await queueIdle(runtime, abort.signal);
@@ -623,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 {
@@ -710,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));
@@ -736,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);
@@ -754,22 +661,11 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
     for (let i = 0; i < pixelCount; i++)
         if (isFlagged[i] === 0 && (pixelFlags[i] & DISPLAY_VIEW_QUALITY_FLAG.highlightUndecided) !== 0)
             undecided.push(i);
-    if (undecided.length > 0 && input.recomputeFlagged !== false) {
-        const signal = createDisplayViewExpectedSignal(signalInput);
-        for (let r = 0; r < undecided.length;) {
-            checkAbort(abort.signal);
-            const first = undecided[r], rx = first % region.width, ry = (first - rx) / region.width;
-            let run = 1;
-            while (r + run < undecided.length && undecided[r + run] === first + run && rx + run < region.width)
-                run++;
-            const part = await renderDisplayView({ ...setup, signal, region: { x: region.x + rx, y: region.y + ry, width: run, height: 1 } });
-            for (let k = 0; k < run; k++) {
-                saturated[first + k] = part.saturated[k];
-                highlights.push(first + k);
-            }
-            r += run;
-        }
-    }
+    if (input.recomputeFlagged !== false)
+        await recomputeRuns(setup, signalInput, undecided, abort, (first, run, part) => { for (let k = 0; k < run; k++) {
+            saturated[first + k] = part.saturated[k];
+            highlights.push(first + k);
+        } });
     if (flagged.length > 0) {
         if (input.recomputeFlagged === false) {
             // Without recomputation a flagged pixel keeps the kernel's values where they are finite (its bound then does not hold).
@@ -787,18 +683,9 @@ export async function renderDisplayViewQualityOnGpu(runtime, bandBytes, input, a
                 varianceBound[i] = MARGIN * moments[o + 10] + quantizationBound(moments, o, meanBound[i], pixels, step);
             }
         }
-        else {
-            const signal = createDisplayViewExpectedSignal(signalInput);
-            // Runs of consecutive flagged pixels along a row are rendered as one region (#457: AHD's choice flags stretches near
-            // edges); a region render is byte-identical to the same pixels of the whole view, so each pixel equals its one-pixel
-            // render, and the run's counts are the sums of its pixels' counts.
-            for (let r = 0; r < flagged.length;) {
-                checkAbort(abort.signal);
-                const first = flagged[r], rx = first % region.width, ry = (first - rx) / region.width;
-                let run = 1;
-                while (r + run < flagged.length && flagged[r + run] === first + run && rx + run < region.width)
-                    run++;
-                const part = await renderDisplayView({ ...setup, signal, region: { x: region.x + rx, y: region.y + ry, width: run, height: 1 } });
+        else
+            await recomputeRuns(setup, signalInput, flagged, abort, (first, run, part) => {
+                // The run's counts are the sums of its pixels' counts.
                 samples.set(part.samples, first * 3);
                 expected.set(part.expected, first * 3);
                 noiseStd.set(part.noiseStd, first * 3);
@@ -808,12 +695,9 @@ 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;
-                r += run;
-            }
-        }
+            });
     }
     timings.recompute = now() - t0;
     const relative = MARGIN * CPU_RELATIVE;
@@ -822,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
@@ -845,8 +729,8 @@ export function qualityMaterialSetup(gpu) {
     const offsets = groups.map((group) => ({ x: group.fx, y: group.fy, weight: 1 / groups.length }));
     const queryPoint = (x, y, o, out) => {
         const group = groups[o];
-        out[0] = (group.fx === 0 ? (x + 0.5 - W / 2) : (x + 0.5 + group.fx - W / 2)) * g;
-        out[1] = -(group.fy === 0 ? (y + 0.5 - H / 2) : (y + 0.5 + group.fy - H / 2)) * g;
+        out[0] = latticeCoordinate(x, group.fx, W, g);
+        out[1] = -latticeCoordinate(y, group.fy, H, g);
     };
     const { kernels: _kernels, ...rest } = input;
     void _kernels;
@@ -856,25 +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) {
-    if (request.scene !== "chart" && request.scene !== "material-layers")
-        return "the scene is a caller " + request.scene + "; the GPU material lookup covers engine charts and declared material-layers scenes (describe the scene as material-layers)";
-    if (request.toneCurve !== "identity" && request.toneCurve !== "positive-reinhard-per-channel")
-        return "unsupported tone curve " + String(request.toneCurve);
-    if (offsetCount(request) > MAXIMUM_GROUPS)
-        return "more than " + MAXIMUM_GROUPS + " query offsets per site";
-    return true;
-}
 /** 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);
@@ -895,66 +760,32 @@ 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.
  */
 async function runQualityConformance(handle, signal, defocus) {
-    const runtime = handle;
-    const nativeWidth = 40, nativeHeight = 28, margin = 1, frameWidth = 38, frameHeight = 26, nodes = [450, 550, 650];
-    const chart = resolvePortableChartScene({ scene: { preset: "checkerboard", squaresAcross: 6 }, aspect: frameHeight / frameWidth });
+    const runtime = handle, { nativeWidth, nativeHeight, frameWidth, nodes } = CONFORMANCE_FRAME, { chart, scene } = conformanceChart();
     const offsets = [];
     for (const [nx, ny] of [[-0.25, -0.25], [0.25, -0.25], [-0.25, 0.25], [0.25, 0.25]])
         for (const [ax, ay] of [[-0.5, -0.5], [0.5, -0.5], [-0.5, 0.5], [0.5, 0.5]])
             offsets.push({ x: nx - ax, y: ny - ay, weight: 1 / 16 });
     const disc = defocus ? createDefocusDiscSiteKernel(6.3) : null;
     const kernels = disc ? { radius: disc.radius, perNode: nodes.map(() => disc.weights) } : { radius: 1, perNode: [syntheticKernel(1, 0.6), syntheticKernel(1, 0.7), syntheticKernel(1, 0.8)] };
-    const signalInput = { nativeWidth, nativeHeight, outputWidth: frameWidth, wavelengthsNm: nodes,
-        electronsPerRadiance: defocus ? [Float64Array.of(9000, 30000, 4000), Float64Array.of(6000, 42000, 9000), Float64Array.of(30000, 9000, 3000)] :
-            [Float64Array.of(900, 3000, 400), Float64Array.of(600, 4200, 900), Float64Array.of(3000, 900, 300)], offsets, kernels,
-        scene: { kind: "materials", materialAt: (u, v) => chart.materialAt(u, v), materials: chart.materials.map((m) => ({ neutral: m.kind === "neutral" ? m.reflectance : 0.5 })), whiteRadiance: Float64Array.of(0.5, 0.9, 0.7) },
-        channelAt: (x, y) => ((y & 1) === 0 ? ((x & 1) === 0 ? 0 : 1) : ((x & 1) === 0 ? 1 : 2)) };
-    const readout = { perElectron: defocus ? 1 / 40000 : 1 / 4000, darkElectrons: 0.07, constantVariance: 2.5e-7 };
-    const bilinear = bilinearKernels();
-    const setup = { frameWidth, frameHeight, margin, nativeWidth, nativeHeight, viewWidth: 13, viewHeight: 9, region: { x: 0, y: 0, width: 13, height: 9 },
-        samplesPerAxis: 16, reachSites: 5 + (disc ? disc.radius : 0), bitDepth: 8, seed: 479, signal: createDisplayViewExpectedSignal(signalInput), readout: [readout, readout, readout], demosaic: bilinear,
-        ...(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 } }),
-        gains: [1.1, 1, 1.6], clipLevel: 1, matrix: [[3.08, -1.54, -0.54], [-0.92, 1.88, 0.045], [0.053, -0.2, 1.15]], toneCurve: "identity",
-        yieldControl: async () => undefined, checkAbort: () => { if (signal?.aborted)
-            throw abortedError(); } };
+    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))),
+        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);
-    const abort = new AbortController(), onAbort = () => abort.abort();
-    signal?.addEventListener("abort", onAbort, { once: true });
-    try {
-        if (signal?.aborted)
-            abort.abort();
+    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, (label, code) => createComputePipeline(runtime, label, code, abort.signal));
-        if (!defocus && (gpu.ahdCorrectedPixelCount === 0 || reference.ahdCorrectedPixelCount === 0))
-            return "the self-check did not exercise the low-signal correction.";
+        const gpu = await renderDisplayViewQualityOnGpu(runtime, 1 << 20, { setup, signalInput, material: chartPresetMaterialModule(chart), ...gather }, abort, undefined, pipelines);
         if (defocus && (!gpu.blockedSum || gpu.stageMilliseconds.siteDispatches < 2))
             return "the self-check did not exercise the blocked site sum over several dispatches.";
-        for (let i = 0; i < reference.expected.length; i++) {
-            const p = Math.floor(i / 3), e0 = reference.expected[i], e1 = gpu.expected[i], v0 = reference.noiseStd[i] * reference.noiseStd[i], v1 = gpu.noiseStd[i] * gpu.noiseStd[i];
-            const expectedLimit = gpu.expectedValueBound.relative * Math.abs(e0) + gpu.expectedValueAbsoluteBound[p], varianceLimit = gpu.varianceBound.relative * v0 + gpu.varianceAbsoluteBound[p];
-            if (!(Math.abs(e1 - e0) <= expectedLimit))
-                return "component " + i + ": expected value " + e1 + " differs from the reference " + e0 + " by more than the a-priori bound " + expectedLimit + ".";
-            if (!(Math.abs(v1 - v0) <= varianceLimit))
-                return "component " + i + ": variance " + v1 + " differs from the reference " + v0 + " by more than the a-priori bound " + varianceLimit + ".";
-            if (Math.abs(gpu.samples[i] - reference.samples[i]) > 1)
-                return "component " + i + ": sample " + gpu.samples[i] + " differs from the reference " + reference.samples[i] + " by more than one code.";
-        }
-        // #533: the saturated-pixel count is the reference's, bit for bit (the light squares sit at the white clip).
-        if (gpu.saturatedPixelCount !== reference.saturatedPixelCount)
-            return "the saturated-pixel count " + gpu.saturatedPixelCount + " differs from the reference's " + reference.saturatedPixelCount + ".";
-        return true;
-    }
-    finally {
-        signal?.removeEventListener("abort", onAbort);
-    }
+        // #533: the verdict includes the saturated-pixel count (the light squares sit at the white clip).
+        return conformanceVerdict(reference, gpu);
+    });
 }
 /** #479's self-check (see `runQualityConformance`). */
 export const DISPLAY_VIEW_QUALITY_CONFORMANCE_CASE = { id: "display-view:quality:checkerboard-13x9-diffraction-ahd",
@@ -962,95 +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 {
-                    material = 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, ...(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