@photivra/engine 2.20.0 → 2.22.0

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

@@ -1,22 +1,9 @@
-/**
- * Host side of the display view's Speed path on the GPU (#478): the support check, the float64 tables (site table,
- * overlaps over the scale, axis sums over the squared scale, 1/Σw²), banded dispatch of
- * `DISPLAY_VIEW_SPEED_KERNEL_WGSL`, and the finishing the CPU reference does after its per-sample loop: the output
- * quantization term, the seeded noise draw, the Cholesky factor, the clipped-normal centre, the sRGB encode and the
- * rounding, all with the reference's own float64 functions. So the noise draw is bit-identical to the CPU's, and only
- * the expected value and the covariance carry the float32 bound.
- *
- * The float64 reference is `renderDisplayView` (facade/display-view.ts) on the exact-area-mean path without
- * diffraction, with the bilinear demosaic and chart materials. Internal: not exported from the package. The
- * material lookup per query point is a module the caller supplies (`DisplayViewGpuMaterialModule`, the seam of
- * #477); `display-view-chart-material-module.ts` provides one for the eight 2.0 chart presets and
- * `display-view-composite-material-module.ts` (#491) one for composite charts, the 2.3 elements and `material-layers` scenes.
- */
-import { type DisplayViewRenderResult, type DisplayViewSetup } from "../facade/display-view.js";
-import type { DisplayViewExpectedSignalInput } from "../facade/expected-signal.js";
+import { type DisplayViewKernelTap, type DisplayViewRenderResult, type DisplayViewSetup } from "../facade/display-view.js";
+import { type DisplayViewExpectedSignalInput } from "../facade/expected-signal.js";
+import { resolvePortableChartScene } from "../facade/chart-scenes.js";
 import { type DisplayViewGpuConformanceCase, type DisplayViewGpuRenderer, type DisplayViewGpuRendererFactory, type DisplayViewGpuRequest } from "../facade/display-view-gpu.js";
 import { type ChartCompositeProbeRecord, type ImageKernelExecution, type ImageKernelRelativeErrorBound } from "./image-kernel-execution.js";
-import { type WebGpuRuntime } from "./webgpu-runtime.js";
+import { GpuResourceScope, type WebGpuRuntime } from "./webgpu-runtime.js";
 type PipelineSource = (label: string, code: string) => Promise<GPUComputePipeline>;
 type YieldControl = ((signal: AbortSignal) => Promise<void>) | undefined;
 /**
@@ -47,6 +34,18 @@ export interface DisplayViewGpuMaterialModule {
         buffer: GPUBuffer;
         data?: undefined;
     })[];
+    /**
+     * #581: a module that defines `scene_value` itself (the image-plane module) states the roundings its value carries beyond the
+     * table lookup's one, added to the mean's and (doubled) the variance's chains; and it gives the data of the kernel's binding 3 in place of the spectral table.
+     */
+    readonly extraSiteRoundings?: number;
+    readonly siteTable?: Float32Array<ArrayBuffer>;
+    /**
+     * #581: a module whose data is too large for one binding (a large photo) gives group 1 per band instead of `bindings`: for the
+     * native site rows [y0, y1] the band reads, and the most display rows a band may hold at `sitesPerDisplayRow`.
+     */
+    band?(scope: GpuResourceScope, layout: GPUBindGroupLayout, y0: number, y1: number): GPUBindGroup;
+    bandRows?(sitesPerDisplayRow: number): number;
 }
 /** What a GPU render of a display view needs: the reference's own setup and expected-signal input, plus the material module. */
 export interface DisplayViewSpeedGpuInput {
@@ -77,7 +76,7 @@ export interface DisplayViewSpeedGpuResult extends DisplayViewRenderResult {
 /**
  * Why the kernel does not cover a request, or null when it does. The kernel is the Speed path: the exact area mean
  * (views where a footprint holds at most 25 real pixels and at most K², and here at most 6 per axis), no diffraction
- * kernels, chart materials, the bilinear demosaic (no AHD candidates or correction), the identity or positive Reinhard
+ * kernels, chart materials, the bilinear demosaic (no AHD candidates), the identity or positive Reinhard
  * tone curve, and at most 16 query offsets.
  */
 export declare function displayViewSpeedGpuUnsupportedReason(setup: DisplayViewSetup, signalInput: DisplayViewExpectedSignalInput): string | null;
@@ -101,7 +100,7 @@ export declare function gaussLegendre16(): {
 /** One axis record of the geometry buffer: first real pixel, count, overlaps over the scale, axis sums over the squared scale. */
 export declare function axisRecord(geometry: Float32Array, at: number, start: number, end: number, limit: number, margin: number, scale: number): void;
 /** The a-priori relative bounds of the expected value and the variance (docs/WEBGPU.md, "Display view (Speed)"), doubled. */
-export declare function displayViewSpeedGpuRelativeBounds(toneCurve: DisplayViewSetup["toneCurve"]): {
+export declare function displayViewSpeedGpuRelativeBounds(toneCurve: DisplayViewSetup["toneCurve"], extraSiteRoundings?: number): {
     mean: number;
     variance: number;
 };
@@ -119,6 +118,12 @@ export declare function finishDisplayViewPixel(moments: ArrayLike<number>, pixel
  * absolute variance bound; it changes no computed value.
  */
 export declare function displayViewSpeedQuantizationBound(moments: ArrayLike<number>, relative: number, absolute: number, pixels: number, step: number): number;
+/**
+ * Renders the display pixels `indices` (ascending, region row-major) with the reference, a run of consecutive pixels along a row
+ * 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 a run's counts are the sums of its pixels'.
+ */
+export declare function recomputeRuns(setup: DisplayViewSetup, signalInput: DisplayViewExpectedSignalInput, indices: readonly number[], abort: AbortController, take: (first: number, run: number, part: DisplayViewRenderResult) => void): Promise<void>;
 /** Renders one region of a Speed display view on the GPU (see the module comment). */
 export declare function renderDisplayViewSpeedOnGpu(runtime: WebGpuRuntime, bandBytes: number, input: DisplayViewSpeedGpuInput, abort: AbortController, yieldControl: YieldControl, pipelines: PipelineSource): Promise<DisplayViewSpeedGpuResult>;
 /**
@@ -130,11 +135,40 @@ export declare function renderDisplayViewSpeedOnGpu(runtime: WebGpuRuntime, band
  * render (`displayViewSpeedGpuUnsupportedReason`, `createDisplayViewMaterialModules`).
  */
 export declare function displayViewSpeedGpuSupports(request: DisplayViewGpuRequest): true | string;
+/** Why the GPU's material lookup, tone curves or query-offset table do not cover a request (shared by the Speed and Quality support checks), or true. */
+export declare function sceneToneAndOffsetsReason(request: DisplayViewGpuRequest, maximumOffsets: number): true | string;
+/**
+ * A self-check's verdict: every component of a GPU render inside its a-priori bounds against the reference, every sample within
+ * one code, and (#533) the saturated-pixel count the reference's bit for bit; true, or a sentence saying where it failed.
+ */
+export declare function conformanceVerdict(reference: DisplayViewRenderResult, gpu: Pick<DisplayViewSpeedGpuResult, "samples" | "expected" | "noiseStd" | "expectedValueBound" | "varianceBound" | "expectedValueAbsoluteBound" | "varianceAbsoluteBound" | "saturatedPixelCount">): true | string;
 /**
  * The renderer's run-time self-check (`DisplayViewGpuRenderer.conformanceCases`): a 38 × 26 checkerboard frame of 6 µm sites
  * shown at 13 × 9 (2.9 real pixels per display pixel) with the 2 × 2 box, light squares at the white clip, the GPU against
  * `renderDisplayView` within the a-priori bounds, every flagged pixel recomputed.
  */
+/** The self-checks' common frame: 40 × 28 native sites (a 38 × 26 frame and a one-site margin) shown at 13 × 9, at three spectral nodes. */
+export declare const CONFORMANCE_FRAME: Readonly<{
+    nativeWidth: 40;
+    nativeHeight: 28;
+    margin: 1;
+    frameWidth: 38;
+    frameHeight: 26;
+    nodes: number[];
+}>;
+/** The self-checks' channel responses per node (`scale` 1, or 1/10 for the low-signal correction's few electrons). */
+export declare function conformanceResponses(scale: number): [Float64Array, Float64Array, Float64Array];
+/** The RGGB channel of a native site. */
+export declare const conformanceChannelAt: (x: number, y: number) => number;
+/** The self-checks' checkerboard and its expected-signal scene (neutral materials under a white radiance per node). */
+export declare function conformanceChart(): {
+    chart: ReturnType<typeof resolvePortableChartScene>;
+    scene: DisplayViewExpectedSignalInput["scene"];
+};
+/** A self-check's setup around its expected-signal input: the common frame and view, the bilinear demosaic, gains, matrix and tone curve, plus `extra`. */
+export declare function conformanceSetup(signalInput: DisplayViewExpectedSignalInput, readout: DisplayViewSetup["readout"][0], seed: number, reachSites: number, signal: AbortSignal | undefined, extra?: Partial<DisplayViewSetup>): DisplayViewSetup;
+/** Runs a self-check's GPU render with an abort controller that follows `signal`, and the device's pipelines under it. */
+export declare function withConformanceAbort<T>(runtime: WebGpuRuntime, signal: AbortSignal | undefined, run: (abort: AbortController, pipelines: PipelineSource) => Promise<T>): Promise<T>;
 export declare const DISPLAY_VIEW_SPEED_CONFORMANCE_CASE: DisplayViewGpuConformanceCase;
 /**
  * The display view's Speed renderer on one runtime (#481's `DisplayViewGpuRenderer`): one pipeline cache per device, the
@@ -155,4 +189,18 @@ export declare const displayViewSpeedGpuRendererFactory: DisplayViewGpuRendererF
  * registered before. Nothing registers it on import: the integration of #481 decides where the engine registers it.
  */
 export declare function registerDisplayViewSpeedGpuRenderer(): DisplayViewGpuRendererFactory | null;
+/** #564: the GPU refusal of a defocus kernel above the direct radius (the CPU convolves it by runs). */
+export declare const LARGE_DEFOCUS_REASON = "a defocus kernel radius above 64 sites (convolved by runs on the CPU, #564) is not on the GPU";
+/** 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;
+};
+/** The pixel-aperture samples per axis and anti-aliasing spots of a request. */
+export declare function offsetCount(request: DisplayViewGpuRequest): number;
+/** The bilinear RGGB demosaic kernels per phase (phaseY·2 + phaseX) and channel, as `bilinearPhaseProfiles` gives them. */
+export declare function bilinearKernels(): DisplayViewKernelTap[][][];
 export {};

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

@@ -13,7 +13,9 @@
  * #477); `display-view-chart-material-module.ts` provides one for the eight 2.0 chart presets and
  * `display-view-composite-material-module.ts` (#491) one for composite charts, the 2.3 elements and `material-layers` scenes.
  */
-import { DISPLAY_VIEW_NOISE_STREAM_ID, axisSums, clipCentre, createDisplayViewExpectedSignal, displayViewDecidedSaturation, overlaps, quantizationVariance, renderDisplayView } from "../facade/display-view.js";
+import { SDR_LUMINANCE_WEIGHTS } from "../output/sdr-rendering.js";
+import { DISPLAY_VIEW_NOISE_STREAM_ID, EXACT_AREA_MEAN_MAX_PIXELS, axisSums, clipCentre, createDisplayViewExpectedSignal, displayViewDecidedSaturation, overlaps, quantizationVariance, renderDisplayView } from "../facade/display-view.js";
+import { displayViewSignalTables } from "../facade/expected-signal.js";
 import { resolvePortableChartScene } from "../facade/chart-scenes.js";
 import { setDisplayViewGpuRendererFactory } from "../facade/display-view-gpu.js";
 import { createDisplayViewMaterialModules } from "./display-view-composite-material-module.js";
@@ -23,8 +25,7 @@ import { createDeterministicUniformStream, deriveNativeSiteStreamSeedUint32, sam
 import { createHostYieldGate } from "../capture/host-yield-cadence.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_AUX, DISPLAY_VIEW_FLAG_WORDS, DISPLAY_VIEW_GEOMETRY_STRIDE, DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS, DISPLAY_VIEW_GPU_MAXIMUM_PIXELS_PER_AXIS, DISPLAY_VIEW_OUTPUT_FLOATS, DISPLAY_VIEW_PARAM_WORDS, DISPLAY_VIEW_REINHARD_MEAN_U, DISPLAY_VIEW_REINHARD_VARIANCE_U, DISPLAY_VIEW_WORKGROUP_SIZE, assembleDisplayViewSpeedWgsl } from "./wgsl-display-view-speed-kernel.js";
-import { footprintShape, bilinearKernels, offsetCount } from "./display-view-quality-gpu.js";
+import { DISPLAY_VIEW_AUX, DISPLAY_VIEW_FLAG_WORDS, DISPLAY_VIEW_SPEED_MAXIMUM_NODES, DISPLAY_VIEW_GEOMETRY_STRIDE, DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS, DISPLAY_VIEW_GPU_MAXIMUM_PIXELS_PER_AXIS, DISPLAY_VIEW_OUTPUT_FLOATS, DISPLAY_VIEW_PARAM_WORDS, DISPLAY_VIEW_REINHARD_MEAN_U, DISPLAY_VIEW_REINHARD_VARIANCE_U, DISPLAY_VIEW_WORKGROUP_SIZE, assembleDisplayViewSpeedWgsl } from "./wgsl-display-view-speed-kernel.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;
 /** Higham's γ_k with E in place of u. */
@@ -52,7 +53,7 @@ const BYTES_PER_PIXEL = 4 * DISPLAY_VIEW_OUTPUT_FLOATS + 4 * DISPLAY_VIEW_FLAG_W
 /**
  * Why the kernel does not cover a request, or null when it does. The kernel is the Speed path: the exact area mean
  * (views where a footprint holds at most 25 real pixels and at most K², and here at most 6 per axis), no diffraction
- * kernels, chart materials, the bilinear demosaic (no AHD candidates or correction), the identity or positive Reinhard
+ * kernels, chart materials, the bilinear demosaic (no AHD candidates), the identity or positive Reinhard
  * tone curve, and at most 16 query offsets.
  */
 export function displayViewSpeedGpuUnsupportedReason(setup, signalInput) {
@@ -60,16 +61,22 @@ export function displayViewSpeedGpuUnsupportedReason(setup, signalInput) {
         return "a defocus kernel radius above 64 sites (convolved by runs on the CPU, #564) is not on the GPU";
     if (signalInput.kernels)
         return "diffraction kernels (the Quality path) are not on the GPU";
-    if (signalInput.scene.kind !== "materials")
+    if (signalInput.scene.kind !== "materials" && !signalInput.scene.signalAt)
         return "radiance scenes (caller functions) are not on the GPU";
     if (!signalInput.queryPoint)
         return "the expected signal has no query points";
-    if (setup.candidates || setup.ahdCorrection || setup.ahdCollect)
-        return "AHD candidates and the low-signal correction are not on the GPU";
-    if (setup.toneCurve !== "identity" && setup.toneCurve !== "positive-reinhard-per-channel")
+    if (setup.candidates || setup.ahdChoice)
+        return "AHD candidates are not on the GPU";
+    if (!GPU_TONE_CURVES.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 (signalInput.offsets.length < 1 || signalInput.offsets.length > DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS)
         return "the kernel holds 1 to " + DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS + " query offsets";
+    if (signalInput.wavelengthsNm.length < 1 || signalInput.wavelengthsNm.length > DISPLAY_VIEW_SPEED_MAXIMUM_NODES)
+        return "the kernel integrates 1 to " + DISPLAY_VIEW_SPEED_MAXIMUM_NODES + " spectral nodes per site";
     if (setup.region.width < 1 || setup.region.height < 1)
         return "an empty region";
     const shape = footprintShape(setup);
@@ -85,27 +92,19 @@ export function displayViewSpeedGpuUnsupportedReason(setup, signalInput) {
         }
     return null;
 }
-/** The site table: Σ_λ A_c(λ)·L_m(λ) per material and channel in float64 (the reference's `materialSignalDirect`), rounded once to float32. */
-function siteTable(signalInput) {
-    const scene = signalInput.scene, A = signalInput.electronsPerRadiance, nodes = signalInput.wavelengthsNm.length;
-    const neutral = [0, 1, 2].map((c) => { let s = 0; for (let n = 0; n < nodes; n++)
-        s += A[c][n] * scene.whiteRadiance[n]; return s; });
-    const table = new Float32Array(scene.materials.length * 3);
-    scene.materials.forEach((m, index) => {
-        for (let c = 0; c < 3; c++) {
-            let value;
-            if ("neutral" in m)
-                value = m.neutral * neutral[c];
-            else {
-                value = 0;
-                for (let n = 0; n < nodes; n++)
-                    value += A[c][n] * m.radiance[n];
-            }
-            if (!(Math.abs(value) <= FLOAT32_SAFE_MAGNITUDE))
-                throw new ImageKernelExecutionError("unsupported-float32-domain", "A material's channel signal exceeds the float32 domain.");
-            table[index * 3 + c] = value;
-        }
-    });
+/**
+ * The spectral table (2.21.0: signals are integrated from the material spectrum per site): the three channel responses A_c(λ_n)
+ * (3·N floats), then each material's spectral radiance L_m(λ_n) (N floats per material; a neutral one its reflectance times the
+ * white radiance, the reference's own float64 spectra), each rounded once to float32. The kernel integrates Σ_n A_c(λ_n)·L_m(λ_n)
+ * for the material and channel a site reads, when it reads it; no per-material channel value is formed.
+ *
+ * Domain: every value is non-negative and the largest possible sum, N·max A·max L, stays below the float32 safe magnitude (NaN fails it).
+ */
+function spectralTable(signalInput) {
+    const N = signalInput.wavelengthsNm.length, rows = [...signalInput.electronsPerRadiance, ...displayViewSignalTables(signalInput).spectra], largest = [0, 0];
+    const table = Float32Array.from(rows.flatMap((row, r) => Array.from(row.subarray(0, N), (v) => { largest[r < 3 ? 0 : 1] = Math.max(largest[r < 3 ? 0 : 1], v >= 0 ? v : Infinity); return v; })));
+    if (!(largest[0] * largest[1] * N <= FLOAT32_SAFE_MAGNITUDE))
+        throw new ImageKernelExecutionError("unsupported-float32-domain", "A material's channel signal exceeds the float32 domain.");
     return table;
 }
 /**
@@ -173,6 +172,8 @@ export function axisRecord(geometry, at, start, end, limit, margin, scale) {
     const order = ["bEven", "bOdd", "ppEven", "ppOdd", "qqEven", "qqOdd", "pqEven", "pqOdd", "ww"];
     order.forEach((key, i) => { geometry[at + 8 + i] = sums[key] / scale2; });
 }
+/** The kernel's tone code: identity 0, positive Reinhard 1, extended Reinhard (luminance) 2, Naka–Rushton (luminance) 3. */
+const TONE_CODE = { "identity": 0, "positive-reinhard-per-channel": 1, "extended-reinhard-luminance": 2, "naka-rushton-luminance": 3 };
 /** The uniform parameters and the aux table of a render. */
 function constants(setup, signalInput) {
     const params = new ArrayBuffer(4 * DISPLAY_VIEW_PARAM_WORDS), words = new Uint32Array(params), floats = new Float32Array(params);
@@ -183,8 +184,9 @@ function constants(setup, signalInput) {
     words[6] = setup.nativeWidth;
     words[7] = setup.nativeHeight;
     words[8] = setup.region.width;
-    words[9] = setup.toneCurve === "positive-reinhard-per-channel" ? 1 : 0;
+    words[9] = TONE_CODE[setup.toneCurve];
     words[10] = signalInput.offsets.length;
+    words[11] = signalInput.wavelengthsNm.length;
     for (let c = 0; c < 3; c++) {
         floats[12 + c] = setup.readout[c].perElectron;
         floats[16 + c] = setup.readout[c].darkElectrons;
@@ -218,10 +220,10 @@ function constants(setup, signalInput) {
     return { params, aux };
 }
 /** The a-priori relative bounds of the expected value and the variance (docs/WEBGPU.md, "Display view (Speed)"), doubled. */
-export function displayViewSpeedGpuRelativeBounds(toneCurve) {
+export function displayViewSpeedGpuRelativeBounds(toneCurve, extraSiteRoundings = 0) {
     const reinhard = toneCurve === "positive-reinhard-per-channel";
-    return { mean: MARGIN * (gammaE(MEAN_ROUNDINGS) + CPU_RELATIVE + (reinhard ? DISPLAY_VIEW_REINHARD_MEAN_U * E : 0)),
-        variance: MARGIN * (gammaE(VARIANCE_ROUNDINGS) + CPU_RELATIVE + (reinhard ? DISPLAY_VIEW_REINHARD_VARIANCE_U * E : 0)) };
+    return { mean: MARGIN * (gammaE(MEAN_ROUNDINGS + extraSiteRoundings) + CPU_RELATIVE + (reinhard ? DISPLAY_VIEW_REINHARD_MEAN_U * E : 0)),
+        variance: MARGIN * (gammaE(VARIANCE_ROUNDINGS + 2 * extraSiteRoundings) + CPU_RELATIVE + (reinhard ? DISPLAY_VIEW_REINHARD_VARIANCE_U * E : 0)) };
 }
 /**
  * The reference's finishing of one display pixel from its linear-light moments (display-view.ts, after the sample loop):
@@ -263,13 +265,31 @@ export function displayViewSpeedQuantizationBound(moments, relative, absolute, p
     }
     return MARGIN * pixels * largest * step * step / 12;
 }
+/**
+ * Renders the display pixels `indices` (ascending, region row-major) with the reference, a run of consecutive pixels along a row
+ * 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 a run's counts are the sums of its pixels'.
+ */
+export async function recomputeRuns(setup, signalInput, indices, abort, take) {
+    const region = setup.region;
+    let reference;
+    for (let r = 0; r < indices.length;) {
+        checkAbort(abort.signal);
+        const first = indices[r], rx = first % region.width, ry = (first - rx) / region.width;
+        let run = 1;
+        while (r + run < indices.length && indices[r + run] === first + run && rx + run < region.width)
+            run++;
+        take(first, run, await renderDisplayView({ ...setup, signal: reference ??= createDisplayViewExpectedSignal(signalInput), region: { x: region.x + rx, y: region.y + ry, width: run, height: 1 } }));
+        r += run;
+    }
+}
 /** Renders one region of a Speed display view on the GPU (see the module comment). */
 export async function renderDisplayViewSpeedOnGpu(runtime, bandBytes, input, abort, yieldControl, pipelines) {
     const { setup, signalInput, material } = input;
     const reason = displayViewSpeedGpuUnsupportedReason(setup, signalInput);
     if (reason)
         throw new ImageKernelExecutionError("unsupported-on-backend", "webgpu-f32 display view (Speed): " + reason + "; use cpu-reference.");
-    const { region, margin } = setup, shape = footprintShape(setup), table = siteTable(signalInput), { params, aux } = constants(setup, signalInput);
+    const { region, margin } = setup, shape = footprintShape(setup), table = material.siteTable ?? spectralTable(signalInput), { params, aux } = constants(setup, signalInput);
     const stride = DISPLAY_VIEW_GEOMETRY_STRIDE, geometry = new Float32Array((region.width + region.height) * stride);
     const columnSums = [], rowSums = [];
     for (let i = 0; i < region.width; i++) {
@@ -281,19 +301,26 @@ export async function renderDisplayViewSpeedOnGpu(runtime, bandBytes, input, abo
         rowSums.push(axisSums((region.y + j) * shape.sy, (region.y + j + 1) * shape.sy, setup.frameHeight, margin));
     }
     const area = shape.sx * shape.sy, pixelCount = region.width * region.height;
-    const rows = Math.max(1, Math.min(region.height, Math.floor(bandBytes / (region.width * BYTES_PER_PIXEL))));
+    const rows = Math.max(1, Math.min(region.height, Math.floor(bandBytes / (region.width * BYTES_PER_PIXEL)), material.bandRows?.(shape.sy) ?? Infinity));
     if (Math.max(rows * region.width * 4 * DISPLAY_VIEW_OUTPUT_FLOATS, geometry.byteLength, table.byteLength) > runtime.maximumStorageBindingBytes)
         throw new ImageKernelExecutionError("insufficient-limits", "One display-view band exceeds the device's storage binding limit.");
-    const pipeline = await pipelines("photivra-display-view-speed:" + material.id, assembleDisplayViewSpeedWgsl(material.wgsl));
+    // #593, #601: the coupled steps' shader 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 pipeline = await pipelines("photivra-display-view-speed:" + material.id + (coupled ? "+coupled" : ""), assembleDisplayViewSpeedWgsl(material.wgsl, coupled?.DISPLAY_VIEW_COUPLED_WGSL));
     const moments = new Float32Array(pixelCount * DISPLAY_VIEW_OUTPUT_FLOATS), flagged = [], flagWords = new Uint32Array(pixelCount * DISPLAY_VIEW_FLAG_WORDS);
     const words = new Uint32Array(params);
     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);
         const tableBuffer = scope.upload("photivra-display-view-table", table, BUFFER_USAGE.STORAGE);
-        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: pipeline.getBindGroupLayout(1), entries: materialEntries });
+        const materialGroup = material.band ? null : runtime.device.createBindGroup({ layout: pipeline.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);
@@ -309,7 +336,8 @@ export async function renderDisplayViewSpeedOnGpu(runtime, bandBytes, input, abo
                         { binding: 0, resource: { buffer: uniform } }, { binding: 1, resource: { buffer: auxBuffer } }, { binding: 2, resource: { buffer: geometryBuffer } },
                         { binding: 3, resource: { buffer: tableBuffer } }, { binding: 4, resource: { buffer: out } }, { binding: 5, resource: { buffer: flagBuffer } }
                     ] });
-                const [data, flagData] = await runComputePass(runtime, band, pipeline, [bindGroup, materialGroup], linearDispatch(count, DISPLAY_VIEW_WORKGROUP_SIZE, runtime.maximumWorkgroupsPerDimension), [{ buffer: out, bytes: count * 4 * DISPLAY_VIEW_OUTPUT_FLOATS }, { buffer: flagBuffer, bytes: count * 4 * DISPLAY_VIEW_FLAG_WORDS }], abort.signal);
+                // #581: a module that bands its own data (a large photo) gives group 1 per band, for the native rows the band reads (with margin).
+                const [data, flagData] = await runComputePass(runtime, band, pipeline, [bindGroup, materialGroup ?? material.band(band, pipeline.getBindGroupLayout(1), Math.floor((region.y + row0) * shape.sy) + margin - 2, Math.ceil((region.y + row1) * shape.sy) + margin + 2)], linearDispatch(count, DISPLAY_VIEW_WORKGROUP_SIZE, runtime.maximumWorkgroupsPerDimension), [{ buffer: out, bytes: count * 4 * DISPLAY_VIEW_OUTPUT_FLOATS }, { buffer: flagBuffer, bytes: count * 4 * DISPLAY_VIEW_FLAG_WORDS }], abort.signal);
                 moments.set(new Float32Array(data, 0, count * DISPLAY_VIEW_OUTPUT_FLOATS), first * DISPLAY_VIEW_OUTPUT_FLOATS);
                 const bandFlags = new Uint32Array(flagData, 0, count * DISPLAY_VIEW_FLAG_WORDS);
                 flagWords.set(bandFlags, first * DISPLAY_VIEW_FLAG_WORDS);
@@ -341,7 +369,7 @@ export async function renderDisplayViewSpeedOnGpu(runtime, bandBytes, input, abo
     const expected = new Float64Array(pixelCount * 3), noiseStd = new Float64Array(pixelCount * 3), saturated = new Float64Array(pixelCount);
     const meanBound = new Float32Array(pixelCount), varianceBound = new Float32Array(pixelCount);
     let largestMean = 0, largestVariance = 0, sampleCount = 0, siteCount = 0;
-    const counts = new Int32Array(geometry.buffer), relative = displayViewSpeedGpuRelativeBounds(setup.toneCurve);
+    const counts = new Int32Array(geometry.buffer), relative = displayViewSpeedGpuRelativeBounds(setup.toneCurve, material.extraSiteRoundings ?? 0);
     // #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));
     for (let ry = 0, i = 0; ry < region.height; ry++) {
@@ -372,33 +400,29 @@ export async function renderDisplayViewSpeedOnGpu(runtime, bandBytes, input, abo
     for (let i = 0; i < pixelCount; i++)
         if (isFlagged[i] === 0 && (flagWords[DISPLAY_VIEW_FLAG_WORDS * i] & 2) !== 0)
             undecided.push(i);
-    if (input.recomputeFlagged !== false && flagged.length + undecided.length > 0) {
-        const signal = createDisplayViewExpectedSignal(signalInput);
-        for (const i of flagged) {
-            checkAbort(abort.signal);
-            const rx = i % region.width, ry = (i - rx) / region.width;
-            const pixel = await renderDisplayView({ ...setup, signal, region: { x: region.x + rx, y: region.y + ry, width: 1, height: 1 } });
-            samples.set(pixel.samples, i * 3);
-            expected.set(pixel.expected, i * 3);
-            noiseStd.set(pixel.noiseStd, i * 3);
-            saturated[i] = pixel.saturated[0];
-            meanBound[i] = 0;
-            varianceBound[i] = 0;
-            recomputed.push(i);
-        }
-        for (const i of undecided) {
-            checkAbort(abort.signal);
-            const rx = i % region.width, ry = (i - rx) / region.width;
-            saturated[i] = (await renderDisplayView({ ...setup, signal, region: { x: region.x + rx, y: region.y + ry, width: 1, height: 1 } })).saturated[0];
-            highlights.push(i);
-        }
+    if (input.recomputeFlagged !== false) {
+        await recomputeRuns(setup, signalInput, flagged, abort, (first, run, part) => {
+            samples.set(part.samples, first * 3);
+            expected.set(part.expected, first * 3);
+            noiseStd.set(part.noiseStd, first * 3);
+            saturated.set(part.saturated, first);
+            for (let k = 0; k < run; k++) {
+                meanBound[first + k] = 0;
+                varianceBound[first + k] = 0;
+                recomputed.push(first + k);
+            }
+        });
+        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);
+        } });
     }
     let saturatedPixelCount = 0;
     for (let i = 0; i < pixelCount; i++)
         saturatedPixelCount += saturated[i];
     const expectedValueBound = { kind: "relative-to-reference", relative: relative.mean, absolute: largestMean };
     const uncertain = flagged.length - recomputed.length + undecided.length - highlights.length;
-    return { samples, expected, noiseStd, sampleCount, siteCount, detailPixelCount: pixelCount, uniformPixelCount: 0, ahdCorrectedPixelCount: 0, 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: relative.variance, absolute: largestVariance },
         expectedValueAbsoluteBound: meanBound, varianceAbsoluteBound: varianceBound,
@@ -417,12 +441,38 @@ export function displayViewSpeedGpuSupports(request) {
         return "AHD (the Quality demosaic) is not on the GPU";
     if (request.diffraction)
         return "diffraction (the Quality optics) is not on the GPU";
-    if (request.scene !== "chart" && request.scene !== "material-layers")
+    return sceneToneAndOffsetsReason(request, DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS);
+}
+/** Why the GPU's material lookup, tone curves or query-offset table do not cover a request (shared by the Speed and Quality support checks), or true. */
+export function sceneToneAndOffsetsReason(request, maximumOffsets) {
+    if (request.scene !== "chart" && request.scene !== "material-layers" && request.scene !== "image-plane")
         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")
+    // #593: the identity, Reinhard and the two luminance tone curves (the luminance curves through the coupled steps).
+    if (!GPU_TONE_CURVES.includes(request.toneCurve))
         return "unsupported tone curve " + String(request.toneCurve);
-    if (offsetCount(request) > DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS)
-        return "more than " + DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS + " query offsets per site";
+    if (offsetCount(request) > maximumOffsets)
+        return "more than " + maximumOffsets + " query offsets per site";
+    return true;
+}
+/** The tone curves the GPU kernels render (#593 adds the luminance curves). */
+const GPU_TONE_CURVES = ["identity", "positive-reinhard-per-channel", "extended-reinhard-luminance", "naka-rushton-luminance"];
+/**
+ * A self-check's verdict: every component of a GPU render inside its a-priori bounds against the reference, every sample within
+ * one code, and (#533) the saturated-pixel count the reference's bit for bit; true, or a sentence saying where it failed.
+ */
+export function conformanceVerdict(reference, gpu) {
+    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.";
+    }
+    if (gpu.saturatedPixelCount !== reference.saturatedPixelCount)
+        return "the saturated-pixel count " + gpu.saturatedPixelCount + " differs from the reference's " + reference.saturatedPixelCount + ".";
     return true;
 }
 /**
@@ -430,48 +480,52 @@ export function displayViewSpeedGpuSupports(request) {
  * shown at 13 × 9 (2.9 real pixels per display pixel) with the 2 × 2 box, light squares at the white clip, the GPU against
  * `renderDisplayView` within the a-priori bounds, every flagged pixel recomputed.
  */
+/** The self-checks' common frame: 40 × 28 native sites (a 38 × 26 frame and a one-site margin) shown at 13 × 9, at three spectral nodes. */
+export const CONFORMANCE_FRAME = /* @__PURE__ */ Object.freeze({ nativeWidth: 40, nativeHeight: 28, margin: 1, frameWidth: 38, frameHeight: 26, nodes: [450, 550, 650] });
+/** The self-checks' channel responses per node (`scale` 1, or 1/10 for the low-signal correction's few electrons). */
+export function conformanceResponses(scale) {
+    return [Float64Array.of(9000, 30000, 4000).map((v) => v * scale), Float64Array.of(6000, 42000, 9000).map((v) => v * scale), Float64Array.of(30000, 9000, 3000).map((v) => v * scale)];
+}
+/** The RGGB channel of a native site. */
+export const conformanceChannelAt = (x, y) => ((y & 1) === 0 ? ((x & 1) === 0 ? 0 : 1) : ((x & 1) === 0 ? 1 : 2));
+/** The self-checks' checkerboard and its expected-signal scene (neutral materials under a white radiance per node). */
+export function conformanceChart() {
+    const chart = resolvePortableChartScene({ scene: { preset: "checkerboard", squaresAcross: 6 }, aspect: CONFORMANCE_FRAME.frameHeight / CONFORMANCE_FRAME.frameWidth });
+    return { chart, 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) } };
+}
+/** A self-check's setup around its expected-signal input: the common frame and view, the bilinear demosaic, gains, matrix and tone curve, plus `extra`. */
+export function conformanceSetup(signalInput, readout, seed, reachSites, signal, extra = {}) {
+    const { frameWidth, frameHeight, margin, nativeWidth, nativeHeight } = CONFORMANCE_FRAME;
+    return { frameWidth, frameHeight, margin, nativeWidth, nativeHeight, viewWidth: 13, viewHeight: 9, region: { x: 0, y: 0, width: 13, height: 9 },
+        samplesPerAxis: 16, reachSites, bitDepth: 8, seed, signal: createDisplayViewExpectedSignal(signalInput), readout: [readout, readout, readout], demosaic: bilinearKernels(),
+        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(); }, ...extra };
+}
+/** Runs a self-check's GPU render with an abort controller that follows `signal`, and the device's pipelines under it. */
+export async function withConformanceAbort(runtime, signal, run) {
+    const abort = new AbortController(), onAbort = () => abort.abort();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+        if (signal?.aborted)
+            abort.abort();
+        return await run(abort, (label, code) => createComputePipeline(runtime, label, code, abort.signal));
+    }
+    finally {
+        signal?.removeEventListener("abort", onAbort);
+    }
+}
 export const DISPLAY_VIEW_SPEED_CONFORMANCE_CASE = { id: "display-view:speed:checkerboard-13x9", async run(handle, signal) {
         // The handle is the engine's own runtime (the contract keeps WebGPU types out of the published declarations).
-        const runtime = handle;
-        const nativeWidth = 40, nativeHeight = 28, margin = 1, frameWidth = 38, frameHeight = 26, g = 2 / frameWidth, nodes = [450, 550, 650];
-        const chart = resolvePortableChartScene({ scene: { preset: "checkerboard", squaresAcross: 6 }, aspect: frameHeight / frameWidth });
+        const runtime = handle, { nativeWidth, nativeHeight, frameWidth, nodes } = CONFORMANCE_FRAME, g = 2 / frameWidth, { chart, scene } = conformanceChart();
         const offsets = [[-0.25, -0.25], [0.25, -0.25], [-0.25, 0.25], [0.25, 0.25]].map(([x, y]) => ({ x: x, y: y, weight: 0.25 }));
-        const signalInput = { nativeWidth, nativeHeight, outputWidth: frameWidth, wavelengthsNm: nodes,
-            electronsPerRadiance: [Float64Array.of(9000, 30000, 4000), Float64Array.of(6000, 42000, 9000), Float64Array.of(30000, 9000, 3000)], offsets,
-            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)),
-            queryPoint: (x, y, o, out) => { out[0] = (x + 0.5 + offsets[o].x - nativeWidth / 2) * g; out[1] = -(y + 0.5 + offsets[o].y - nativeHeight / 2) * g; } };
-        const readout = { perElectron: 1 / 60000, darkElectrons: 0.07, constantVariance: 1.5e-9 };
-        const setup = { frameWidth, frameHeight, margin, nativeWidth, nativeHeight, viewWidth: 13, viewHeight: 9, region: { x: 0, y: 0, width: 13, height: 9 },
-            samplesPerAxis: 16, reachSites: 2, bitDepth: 8, seed: 478, signal: createDisplayViewExpectedSignal(signalInput), readout: [readout, readout, readout], demosaic: bilinearKernels(),
-            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(1), offsets, scene,
+            channelAt: conformanceChannelAt, queryPoint: (x, y, o, out) => { out[0] = (x + 0.5 + offsets[o].x - nativeWidth / 2) * g; out[1] = -(y + 0.5 + offsets[o].y - nativeHeight / 2) * g; } };
+        const setup = conformanceSetup(signalInput, { perElectron: 1 / 60000, darkElectrons: 0.07, constantVariance: 1.5e-9 }, 478, 2, signal);
         const reference = await renderDisplayView(setup);
-        const abort = new AbortController(), onAbort = () => abort.abort();
-        signal?.addEventListener("abort", onAbort, { once: true });
-        try {
-            if (signal?.aborted)
-                abort.abort();
-            const gpu = await renderDisplayViewSpeedOnGpu(runtime, 1 << 20, { setup, signalInput, material: chartPresetMaterialModule(chart) }, abort, undefined, (label, code) => createComputePipeline(runtime, label, code, abort.signal));
-            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 await withConformanceAbort(runtime, signal, async (abort, pipelines) => conformanceVerdict(reference, await renderDisplayViewSpeedOnGpu(runtime, 1 << 20, { setup, signalInput, material: chartPresetMaterialModule(chart) }, abort, undefined, pipelines)));
     } };
 /**
  * The display view's Speed renderer on one runtime (#481's `DisplayViewGpuRenderer`): one pipeline cache per device, the
@@ -510,7 +564,7 @@ export function createDisplayViewSpeedGpuRenderer(runtime, options = {}) {
                 const material = await modules.moduleFor(setup.gpu, abort.signal);
                 const result = await renderDisplayViewSpeedOnGpu(runtime, bandBytes, { setup, signalInput: setup.gpu.signalInput, material }, 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,
+                    uniformPixelCount: result.uniformPixelCount, estimation: result.estimation, saturated: result.saturated,
                     saturatedPixelCount: result.saturatedPixelCount, errorBound: result.expectedValueBound,
                     diagnosticUncertaintySampleCount: result.execution.diagnosticUncertaintySampleCount, ...(material.compositeProbe ? { compositeProbe: material.compositeProbe } : {}) };
             }
@@ -530,4 +584,26 @@ export const displayViewSpeedGpuRendererFactory = (handle) => createDisplayViewS
 export function registerDisplayViewSpeedGpuRenderer() {
     return setDisplayViewGpuRendererFactory(displayViewSpeedGpuRendererFactory);
 }
+// #594: shared with the on-demand Quality host (display-view-quality-gpu.ts), so the Speed path does not import it.
+/** #564: the GPU refusal of a defocus kernel above the direct radius (the CPU convolves it by runs). */
+export const LARGE_DEFOCUS_REASON = "a defocus kernel radius above 64 sites (convolved by runs on the CPU, #564) is not on the GPU";
+/** 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 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); }
+/** 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]];
+}
 //# sourceMappingURL=display-view-speed-gpu.js.map