@photivra/engine 2.10.0 → 2.11.1

package/dist/gpu/display-view-composite-material-module.js

@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The composite-chart and mask-layer material module of the GPU display view (#491): the Speed kernel's `material_at`
+ * (the seam of #478, `DisplayViewGpuMaterialModule`) built from the composite chart kernel's classification (#477,
+ * `wgsl-chart-composite-kernel.ts`: `material()`, its bound arithmetic and double-float32), so that composite charts,
+ * every 2.3 element as a plain chart, the sine-profile Siemens star and declared `material-layers` scenes render on the
+ * GPU. The scene's packed records (`packChartScene`) are uploaded once per renderer and reused across a view's parts,
+ * as the composite kernel reuses them per accelerator; the device probe of the composite kernel gates the module.
+ *
+ * **The query point.** The Speed kernel hands the module p = fl(fl(x + c)·scale) per axis: the site coordinate x plus the
+ * offset constant c = 0.5 + o − W/2 (`DISPLAY_VIEW_AUX.offsets`), times the frame-units-per-site scale rounded once to
+ * float32, so p carries up to 2E relative error (E = 2⁻²³) against the reference's float64 query point. The composite
+ * kernel's chirp decisions (the zone plate's phase, the stars' sector cross products) need the point to about 2⁻⁴⁰; fed
+ * p directly they would flag most of a 64-cycle sine star. The module therefore **recovers the exact lattice point**: it
+ * knows the offsets c_o (uploaded as float32 hi + lo pairs) and the scale (hi + lo), divides p by the scale's high part
+ * (within 6E·|s| of s = x + c_o), picks the offset whose c_o puts the quotient nearest an integer x, and re-forms the point
+ * in double-float32 as (x + c_o)·scale from the exact integer and the float64 constants. The host admits a lattice only
+ * when the recovery is unambiguous: the distinct fractional parts of the offsets (mod 1) lie more than four tolerances
+ * apart, the tolerance being 8E·max|s| + 2⁻¹²; a point whose residual exceeds the tolerance on the device is flagged.
+ * The recovered point differs from the exact (x + c_o)·g by at most about 2⁻⁴⁶ relative (two double-float32 operations
+ * and the split constants' 2⁻⁴⁸), inside the composite kernel's own allowance for a point (DW = 2⁻⁴⁰ relative in `bd`).
+ * The reference's own float64 query point differs from the exact lattice value by its float64 rounding only: measured at
+ * most 5.6·10⁻¹⁶ absolute over every site and offset of the #491 fixtures, and checked by the host at the frame's four
+ * corners within 2⁻⁴⁸·(|p| + 1); that is inside the composite kernel's 10⁻¹⁴ slack for the reference's rounding. So the
+ * composite kernel's bounds and SAFETY factor (4) apply unchanged, and the module's point error is far inside the Speed
+ * kernel's contract (≤ 2E + 10⁻¹⁴): no Speed bound term changes.
+ *
+ * **A fixed-size chart** (`chartSize`): the reference maps the frame point to chart-local units, cu = (u·m)/h with m the
+ * metres per frame unit and h the chart's half width, and returns the surround material outside |cu| ≤ 1, |cv| ≤ aspect.
+ * The module multiplies the recovered point by k = m/h (hi + lo) in double-float32 and tests the chart rectangle in bound
+ * arithmetic (flagging points within their bound of its edge); the surround is the materials table's last entry.
+ */
+import { ImageKernelExecutionError, WEBGPU_F32_UNIT_ROUNDOFF } from "./image-kernel-execution.js";
+import { chartCompositeWgsl } from "./wgsl-chart-composite-kernel.js";
+import { chartGpuPresetCode } from "./chart-radiance-gpu.js";
+import { dwSplit, packChartScene, probeChartCompositeDevice } from "./chart-composite-gpu.js";
+import { chartPresetMaterialModule } from "./display-view-chart-material-module.js";
+import { BUFFER_USAGE, GpuResourceScope } from "./webgpu-runtime.js";
+import { DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS } from "./wgsl-display-view-speed-kernel.js";
+/** One WGSL rounding of + − × in either direction (E = 2⁻²³). */
+const E = 2 * WEBGPU_F32_UNIT_ROUNDOFF;
+/** The module's id in the pipeline cache (one shader per product path for every composite scene; the scene is data): the Dekker path's. */
+export const CHART_COMPOSITE_MATERIAL_MODULE_ID = "chart-composite";
+/** The module's id per product path (the fma path's shader is a different pipeline). */
+export function chartCompositeMaterialModuleId(path) { return path === "dekker" ? CHART_COMPOSITE_MATERIAL_MODULE_ID : CHART_COMPOSITE_MATERIAL_MODULE_ID + "-fma"; }
+/** Scenes whose records stay uploaded per renderer (the composite kernel keeps the same number per accelerator). */
+const KEPT_SCENES = 4;
+/** The corner check of the query-point model against the reference's own query points, relative to |p| + 1 (inside the composite kernel's 10⁻¹⁴ slack). */
+const MODEL_TOLERANCE = 2 ** -48;
+/** Layout of the lattice uniform (float32 / u32 words, 48 bytes) and the offsets table (one vec4 per offset: cu hi, cu lo, cv hi, cv lo). */
+export const DISPLAY_VIEW_LATTICE = Object.freeze({ scaleUHi: 0, scaleULo: 1, scaleVHi: 2, scaleVLo: 3, chartKHi: 4, chartKLo: 5, chartAspect: 6, tolerance: 7, offsets: 8, placed: 9, surround: 10, zero: 11, words: 12 });
+/**
+ * The composite kernel's classification (`material(p: vec4<f32>)` with its bound arithmetic, double-float32, cos polynomial,
+ * elements and layers) renamed for the display-view kernel, its records bound at @group(1), and the lattice recovery that
+ * defines `material_at(p: vec2<f32>)` (see the module comment). The constants E and SLACK come from the kernel's preamble. `path`
+ * is the double-word product path the device's probe chose (default Dekker's).
+ */
+export function chartCompositeMaterialWgsl(path = "dekker") {
+    const source = chartCompositeWgsl(path);
+    const commonStart = source.indexOf("const DW: f32"), commonEnd = source.indexOf("struct Params"), bodyStart = source.indexOf("const SEGMENT_BOX"), bodyEnd = source.indexOf("@compute");
+    if (commonStart < 0 || commonEnd < commonStart || bodyStart < commonEnd || bodyEnd < bodyStart)
+        throw new ImageKernelExecutionError("gpu-validation", "The composite chart kernel's material functions were not found.");
+    const rename = (code) => code.replace(/^const SLACK: f32 = [^\n]*\n/mu, "").replace(/\bflagged\b/gu, "material_uncertain").replace(/\bmargin\(/gu, "bmargin(").replace(/\bparams\.zero\b/gu, "lattice.zero");
+    return `${rename(source.slice(commonStart, commonEnd))}
+@group(1) @binding(0) var<storage, read> af: array<f32>;
+@group(1) @binding(1) var<storage, read> ai: array<u32>;
+struct LatticeParams {
+  scale_u_hi: f32, scale_u_lo: f32, scale_v_hi: f32, scale_v_lo: f32,
+  chart_k_hi: f32, chart_k_lo: f32, chart_aspect: f32, tolerance: f32,
+  offsets: u32, placed: u32, surround: u32, zero: u32,
+};
+@group(1) @binding(2) var<uniform> lattice: LatticeParams;
+@group(1) @binding(3) var<storage, read> lattice_offsets: array<vec4<f32>>;
+${rename(source.slice(bodyStart, bodyEnd))}
+// The exact lattice point of one axis from the kernel's p = fl(fl(x + c)·scale): the offset whose constant c puts p/scale
+// nearest an integer x, then (x + c)·scale in double-float32 from the exact integer and the float64 constants (hi + lo).
+fn lattice_point(p: f32, scale: D, axis: u32) -> D {
+  let rough = p / scale.h;
+  var best = 3.0e38; var site = 0.0; var c_hi = 0.0; var c_lo = 0.0;
+  for (var o = 0u; o < lattice.offsets; o = o + 1u) {
+    let row = lattice_offsets[o];
+    let hi = select(row.z, row.x, axis == 0u);
+    let lo = select(row.w, row.y, axis == 0u);
+    let d = rough - hi;
+    let n = round(d);
+    let r = abs(d - n);
+    if (r < best) { best = r; site = n; c_hi = hi; c_lo = lo; }
+  }
+  if (!(best <= lattice.tolerance)) { material_uncertain = true; }
+  return d_mul(d_add(D(site, 0.0), D(c_hi, c_lo)), scale);
+}
+fn material_at(p: vec2<f32>) -> u32 {
+  var u = lattice_point(p.x, D(lattice.scale_u_hi, lattice.scale_u_lo), 0u);
+  var v = lattice_point(p.y, D(lattice.scale_v_hi, lattice.scale_v_lo), 1u);
+  if (lattice.placed != 0u) {
+    let k = D(lattice.chart_k_hi, lattice.chart_k_lo);
+    u = d_mul(u, k); v = d_mul(v, k);
+    if (!(le(babs(bd(u)), bx(1.0)) && le(babs(bd(v)), bc(lattice.chart_aspect)))) { return lattice.surround; }
+  }
+  return material(vec4<f32>(u.h, u.l, v.h, v.l));
+}
+`;
+}
+/**
+ * The query lattice of an expected-signal input as the module needs it, or an `unsupported-on-backend` error: the scale per
+ * axis from the reference's own query points (two sites a frame apart), the model (x + c)·scale checked against the reference
+ * at the frame's four corners for every offset within 2⁻⁴⁸·(|p| + 1), the offsets as hi + lo pairs, and the recovery tolerance
+ * 8E·max|x + c| + 2⁻¹², which the distinct fractional parts of the offsets must clear four times over.
+ */
+export function displayViewLatticeConstants(signalInput, placement, surroundMaterial) {
+    const W = signalInput.nativeWidth, H = signalInput.nativeHeight, offsets = signalInput.offsets, query = signalInput.queryPoint;
+    if (!query)
+        throw new ImageKernelExecutionError("unsupported-on-backend", "The expected signal has no query points (the Quality path); use cpu-reference.");
+    if (offsets.length < 1 || offsets.length > DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS)
+        throw new ImageKernelExecutionError("unsupported-on-backend", "The kernel holds 1 to " + DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS + " query offsets.");
+    if (!(W >= 2 && H >= 2 && W <= 2 ** 20 && H <= 2 ** 20))
+        throw new ImageKernelExecutionError("unsupported-on-backend", "The native frame is outside the lattice recovery's range (2 to 2^20 sites per axis).");
+    const point = new Float64Array(2), x1 = W - 1, y1 = H - 1;
+    query(0, 0, 0, point);
+    const u0 = point[0], v0 = point[1];
+    query(x1, 0, 0, point);
+    const u1 = point[0];
+    query(0, y1, 0, point);
+    const v1 = point[1];
+    const scaleU = (u1 - u0) / x1, scaleV = (v1 - v0) / y1;
+    if (!(Number.isFinite(scaleU) && Number.isFinite(scaleV) && scaleU !== 0 && scaleV !== 0))
+        throw new ImageKernelExecutionError("unsupported-on-backend", "The request's query lattice has no scale; use cpu-reference.");
+    const cu = new Float64Array(offsets.length), cv = new Float64Array(offsets.length);
+    let smax = 0;
+    for (let o = 0; o < offsets.length; o++) {
+        const offset = offsets[o];
+        cu[o] = 0.5 + offset.x - W / 2;
+        cv[o] = 0.5 + offset.y - H / 2;
+        smax = Math.max(smax, Math.abs(cu[o]), Math.abs(x1 + cu[o]), Math.abs(cv[o]), Math.abs(y1 + cv[o]));
+        for (const [x, y] of [[0, 0], [x1, 0], [0, y1], [x1, y1]]) {
+            query(x, y, o, point);
+            const mu = (x + cu[o]) * scaleU, mv = (y + cv[o]) * scaleV;
+            if (!(Math.abs(mu - point[0]) <= MODEL_TOLERANCE * (Math.abs(point[0]) + 1) && Math.abs(mv - point[1]) <= MODEL_TOLERANCE * (Math.abs(point[1]) + 1)))
+                throw new ImageKernelExecutionError("unsupported-on-backend", "The request's query points are not a rectilinear site lattice within 2^-48; use cpu-reference.");
+        }
+    }
+    const tolerance = Math.fround(8 * E * smax + 2 ** -12);
+    if (!(tolerance < 1 / 8))
+        throw new ImageKernelExecutionError("unsupported-on-backend", "The query lattice is too wide for the exact point recovery; use cpu-reference.");
+    // Distinct fractional parts of the offsets must be told apart on the device: more than four tolerances apart, or an exact integer apart (the same lattice).
+    for (const axis of [cu, cv]) {
+        for (let a = 0; a < axis.length; a++)
+            for (let b = a + 1; b < axis.length; b++) {
+                const delta = axis[a] - axis[b], fractional = Math.abs(delta - Math.round(delta));
+                if (fractional !== 0 && !(fractional > 4 * tolerance))
+                    throw new ImageKernelExecutionError("unsupported-on-backend", "Two query offsets are too close (mod one site) for the exact point recovery; use cpu-reference.");
+            }
+    }
+    const params = new ArrayBuffer(4 * DISPLAY_VIEW_LATTICE.words), floats = new Float32Array(params), words = new Uint32Array(params);
+    const [suH, suL] = dwSplit(scaleU), [svH, svL] = dwSplit(scaleV);
+    floats[DISPLAY_VIEW_LATTICE.scaleUHi] = suH;
+    floats[DISPLAY_VIEW_LATTICE.scaleULo] = suL;
+    floats[DISPLAY_VIEW_LATTICE.scaleVHi] = svH;
+    floats[DISPLAY_VIEW_LATTICE.scaleVLo] = svL;
+    if (placement) {
+        const [kH, kL] = dwSplit(placement.chartUnitsPerFrameUnit);
+        if (!(Number.isFinite(kH) && kH > 0 && Number.isFinite(placement.aspect) && placement.aspect > 0))
+            throw new ImageKernelExecutionError("unsupported-on-backend", "The chart placement is not finite.");
+        floats[DISPLAY_VIEW_LATTICE.chartKHi] = kH;
+        floats[DISPLAY_VIEW_LATTICE.chartKLo] = kL;
+        floats[DISPLAY_VIEW_LATTICE.chartAspect] = placement.aspect;
+    }
+    floats[DISPLAY_VIEW_LATTICE.tolerance] = tolerance;
+    words[DISPLAY_VIEW_LATTICE.offsets] = offsets.length;
+    words[DISPLAY_VIEW_LATTICE.placed] = placement ? 1 : 0;
+    words[DISPLAY_VIEW_LATTICE.surround] = surroundMaterial;
+    words[DISPLAY_VIEW_LATTICE.zero] = 0; // the rounding barrier's zero (`lattice.zero`)
+    const table = new Float32Array(4 * offsets.length);
+    for (let o = 0; o < offsets.length; o++) {
+        const [uH, uL] = dwSplit(cu[o]), [vH, vL] = dwSplit(cv[o]);
+        table[4 * o] = uH;
+        table[4 * o + 1] = uL;
+        table[4 * o + 2] = vH;
+        table[4 * o + 3] = vL;
+    }
+    return { params, offsets: table, tolerance, scaleU, scaleV };
+}
+/** The resolved scene behind a GPU setup: the chart whose geometry is packed, the layers (or null) and the materials the kernel indexes. */
+function sceneOf(gpu) {
+    if (gpu.layers)
+        return { chart: gpu.layers.chart, layers: gpu.layers, materials: gpu.layers.materials, key: gpu.layers };
+    if (gpu.chart)
+        return { chart: gpu.chart, layers: null, materials: gpu.chart.materials, key: gpu.chart };
+    throw new ImageKernelExecutionError("unsupported-on-backend", "The GPU material lookup covers chart presets, composite charts and declared material-layers scenes; a caller scene function runs on cpu-reference (describe it as material-layers).");
+}
+export function createDisplayViewMaterialModules(runtime, pipelines) {
+    const presets = new WeakMap(), uploads = [];
+    let probed = null;
+    const wgsl = new Map();
+    const probe = (signal) => {
+        probed ??= probeChartCompositeDevice(runtime, pipelines, signal).catch((error) => { probed = null; throw error; });
+        return probed;
+    };
+    const records = (scene) => {
+        const index = uploads.findIndex((e) => e.key === scene.key);
+        if (index >= 0) {
+            const [entry] = uploads.splice(index, 1);
+            uploads.push(entry);
+            return entry;
+        }
+        // packChartScene reads the plan's chart, layers and materials only.
+        const packed = packChartScene({ chart: scene.chart, layers: scene.layers, materials: scene.materials });
+        if (Math.max(packed.af.byteLength, packed.ai.byteLength) > runtime.maximumStorageBindingBytes)
+            throw new ImageKernelExecutionError("insufficient-limits", "Chart records exceed the device's storage binding limit.");
+        const scope = new GpuResourceScope(runtime);
+        const entry = { key: scene.key, scope, af: scope.upload("photivra-display-view-chart-floats", packed.af, BUFFER_USAGE.STORAGE), ai: scope.upload("photivra-display-view-chart-records", packed.ai, BUFFER_USAGE.STORAGE), packed };
+        uploads.push(entry);
+        while (uploads.length > KEPT_SCENES)
+            uploads.shift().scope.release();
+        return entry;
+    };
+    return {
+        async moduleFor(gpu, signal) {
+            const scene = sceneOf(gpu), placement = gpu.placement ?? null, signalInput = gpu.signalInput;
+            const tableMaterials = signalInput.scene.kind === "materials" ? signalInput.scene.materials.length : -1;
+            if (tableMaterials !== scene.materials.length + (placement ? 1 : 0))
+                throw new ImageKernelExecutionError("unsupported-on-backend", "The expected signal's materials do not match the scene's (" + tableMaterials + " against " + scene.materials.length + (placement ? " plus the surround" : "") + "); use cpu-reference.");
+            if (!scene.layers && !placement && chartGpuPresetCode({ chart: scene.chart }) !== undefined) {
+                let module = presets.get(scene.chart);
+                if (!module) {
+                    module = chartPresetMaterialModule(scene.chart);
+                    presets.set(scene.chart, module);
+                }
+                return module;
+            }
+            const record = await probe(signal), path = record.productPath ?? "dekker";
+            const lattice = displayViewLatticeConstants(signalInput, placement, scene.materials.length), uploaded = records(scene);
+            let code = wgsl.get(path);
+            if (code === undefined) {
+                code = chartCompositeMaterialWgsl(path);
+                wgsl.set(path, code);
+            }
+            return { id: chartCompositeMaterialModuleId(path), wgsl: code, compositeProbe: record, bindings: [
+                    { binding: 0, kind: "storage", buffer: uploaded.af }, { binding: 1, kind: "storage", buffer: uploaded.ai },
+                    { binding: 2, kind: "uniform", data: new Uint8Array(lattice.params) }, { binding: 3, kind: "storage", data: lattice.offsets }
+                ] };
+        },
+        get uploadedScenes() { return uploads.length; },
+        release() { for (const entry of uploads.splice(0))
+            entry.scope.release(); }
+    };
+}
+//# sourceMappingURL=display-view-composite-material-module.js.map

package/dist/gpu/display-view-composite-material-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-view-composite-material-module.js","sourceRoot":"","sources":["../../src/gpu/display-view-composite-material-module.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The composite-chart and mask-layer material module of the GPU display view (#491): the Speed kernel's `material_at`\n * (the seam of #478, `DisplayViewGpuMaterialModule`) built from the composite chart kernel's classification (#477,\n * `wgsl-chart-composite-kernel.ts`: `material()`, its bound arithmetic and double-float32), so that composite charts,\n * every 2.3 element as a plain chart, the sine-profile Siemens star and declared `material-layers` scenes render on the\n * GPU. The scene's packed records (`packChartScene`) are uploaded once per renderer and reused across a view's parts,\n * as the composite kernel reuses them per accelerator; the device probe of the composite kernel gates the module.\n *\n * **The query point.** The Speed kernel hands the module p = fl(fl(x + c)·scale) per axis: the site coordinate x plus the\n * offset constant c = 0.5 + o − W/2 (`DISPLAY_VIEW_AUX.offsets`), times the frame-units-per-site scale rounded once to\n * float32, so p carries up to 2E relative error (E = 2⁻²³) against the reference's float64 query point. The composite\n * kernel's chirp decisions (the zone plate's phase, the stars' sector cross products) need the point to about 2⁻⁴⁰; fed\n * p directly they would flag most of a 64-cycle sine star. The module therefore **recovers the exact lattice point**: it\n * knows the offsets c_o (uploaded as float32 hi + lo pairs) and the scale (hi + lo), divides p by the scale's high part\n * (within 6E·|s| of s = x + c_o), picks the offset whose c_o puts the quotient nearest an integer x, and re-forms the point\n * in double-float32 as (x + c_o)·scale from the exact integer and the float64 constants. The host admits a lattice only\n * when the recovery is unambiguous: the distinct fractional parts of the offsets (mod 1) lie more than four tolerances\n * apart, the tolerance being 8E·max|s| + 2⁻¹²; a point whose residual exceeds the tolerance on the device is flagged.\n * The recovered point differs from the exact (x + c_o)·g by at most about 2⁻⁴⁶ relative (two double-float32 operations\n * and the split constants' 2⁻⁴⁸), inside the composite kernel's own allowance for a point (DW = 2⁻⁴⁰ relative in `bd`).\n * The reference's own float64 query point differs from the exact lattice value by its float64 rounding only: measured at\n * most 5.6·10⁻¹⁶ absolute over every site and offset of the #491 fixtures, and checked by the host at the frame's four\n * corners within 2⁻⁴⁸·(|p| + 1); that is inside the composite kernel's 10⁻¹⁴ slack for the reference's rounding. So the\n * composite kernel's bounds and SAFETY factor (4) apply unchanged, and the module's point error is far inside the Speed\n * kernel's contract (≤ 2E + 10⁻¹⁴): no Speed bound term changes.\n *\n * **A fixed-size chart** (`chartSize`): the reference maps the frame point to chart-local units, cu = (u·m)/h with m the\n * metres per frame unit and h the chart's half width, and returns the surround material outside |cu| ≤ 1, |cv| ≤ aspect.\n * The module multiplies the recovered point by k = m/h (hi + lo) in double-float32 and tests the chart rectangle in bound\n * arithmetic (flagging points within their bound of its edge); the surround is the materials table's last entry.\n */\nimport { ImageKernelExecutionError, WEBGPU_F32_UNIT_ROUNDOFF } from \"./image-kernel-execution.js\";\nimport { chartCompositeWgsl, type ChartCompositeProductPath } from \"./wgsl-chart-composite-kernel.js\";\nimport { chartGpuPresetCode } from \"./chart-radiance-gpu.js\";\nimport { dwSplit, packChartScene, probeChartCompositeDevice, type PackedChartScene } from \"./chart-composite-gpu.js\";\nimport type { ChartCompositeProbeRecord } from \"./image-kernel-execution.js\";\nimport { chartPresetMaterialModule } from \"./display-view-chart-material-module.js\";\nimport type { ChartRadianceBatchPlan } from \"../facade/chart-radiance-batch.js\";\nimport type { ResolvedChartScene } from \"../facade/chart-scenes.js\";\nimport type { ResolvedChartMaterialLayers } from \"../facade/chart-material-layers.js\";\nimport type { DisplayViewExpectedSignalInput } from \"../facade/expected-signal.js\";\nimport type { DisplayViewGpuSetup } from \"../facade/display-view.js\";\nimport { BUFFER_USAGE, GpuResourceScope, type WebGpuRuntime } from \"./webgpu-runtime.js\";\nimport { DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS } from \"./wgsl-display-view-speed-kernel.js\";\nimport type { DisplayViewGpuMaterialModule } from \"./display-view-speed-gpu.js\";\n\ntype PipelineSource = (label: string, code: string) => Promise<GPUComputePipeline>;\n\n/** One WGSL rounding of + − × in either direction (E = 2⁻²³). */\nconst E = 2 * WEBGPU_F32_UNIT_ROUNDOFF;\n/** The module's id in the pipeline cache (one shader per product path for every composite scene; the scene is data): the Dekker path's. */\nexport const CHART_COMPOSITE_MATERIAL_MODULE_ID = \"chart-composite\";\n/** The module's id per product path (the fma path's shader is a different pipeline). */\nexport function chartCompositeMaterialModuleId(path: ChartCompositeProductPath): string { return path === \"dekker\" ? CHART_COMPOSITE_MATERIAL_MODULE_ID : CHART_COMPOSITE_MATERIAL_MODULE_ID + \"-fma\"; }\n/** Scenes whose records stay uploaded per renderer (the composite kernel keeps the same number per accelerator). */\nconst KEPT_SCENES = 4;\n/** The corner check of the query-point model against the reference's own query points, relative to |p| + 1 (inside the composite kernel's 10⁻¹⁴ slack). */\nconst MODEL_TOLERANCE = 2 ** -48;\n\n/** Layout of the lattice uniform (float32 / u32 words, 48 bytes) and the offsets table (one vec4 per offset: cu hi, cu lo, cv hi, cv lo). */\nexport const DISPLAY_VIEW_LATTICE = Object.freeze({ scaleUHi: 0, scaleULo: 1, scaleVHi: 2, scaleVLo: 3, chartKHi: 4, chartKLo: 5, chartAspect: 6, tolerance: 7, offsets: 8, placed: 9, surround: 10, zero: 11, words: 12 });\n\n/**\n * The composite kernel's classification (`material(p: vec4<f32>)` with its bound arithmetic, double-float32, cos polynomial,\n * elements and layers) renamed for the display-view kernel, its records bound at @group(1), and the lattice recovery that\n * defines `material_at(p: vec2<f32>)` (see the module comment). The constants E and SLACK come from the kernel's preamble. `path`\n * is the double-word product path the device's probe chose (default Dekker's).\n */\nexport function chartCompositeMaterialWgsl(path: ChartCompositeProductPath = \"dekker\"): string {\n  const source = chartCompositeWgsl(path);\n  const commonStart = source.indexOf(\"const DW: f32\"), commonEnd = source.indexOf(\"struct Params\"), bodyStart = source.indexOf(\"const SEGMENT_BOX\"), bodyEnd = source.indexOf(\"@compute\");\n  if (commonStart < 0 || commonEnd < commonStart || bodyStart < commonEnd || bodyEnd < bodyStart) throw new ImageKernelExecutionError(\"gpu-validation\", \"The composite chart kernel's material functions were not found.\");\n  const rename = (code: string): string => code.replace(/^const SLACK: f32 = [^\\n]*\\n/mu, \"\").replace(/\\bflagged\\b/gu, \"material_uncertain\").replace(/\\bmargin\\(/gu, \"bmargin(\").replace(/\\bparams\\.zero\\b/gu, \"lattice.zero\");\n  return `${rename(source.slice(commonStart, commonEnd))}\n@group(1) @binding(0) var<storage, read> af: array<f32>;\n@group(1) @binding(1) var<storage, read> ai: array<u32>;\nstruct LatticeParams {\n  scale_u_hi: f32, scale_u_lo: f32, scale_v_hi: f32, scale_v_lo: f32,\n  chart_k_hi: f32, chart_k_lo: f32, chart_aspect: f32, tolerance: f32,\n  offsets: u32, placed: u32, surround: u32, zero: u32,\n};\n@group(1) @binding(2) var<uniform> lattice: LatticeParams;\n@group(1) @binding(3) var<storage, read> lattice_offsets: array<vec4<f32>>;\n${rename(source.slice(bodyStart, bodyEnd))}\n// The exact lattice point of one axis from the kernel's p = fl(fl(x + c)·scale): the offset whose constant c puts p/scale\n// nearest an integer x, then (x + c)·scale in double-float32 from the exact integer and the float64 constants (hi + lo).\nfn lattice_point(p: f32, scale: D, axis: u32) -> D {\n  let rough = p / scale.h;\n  var best = 3.0e38; var site = 0.0; var c_hi = 0.0; var c_lo = 0.0;\n  for (var o = 0u; o < lattice.offsets; o = o + 1u) {\n    let row = lattice_offsets[o];\n    let hi = select(row.z, row.x, axis == 0u);\n    let lo = select(row.w, row.y, axis == 0u);\n    let d = rough - hi;\n    let n = round(d);\n    let r = abs(d - n);\n    if (r < best) { best = r; site = n; c_hi = hi; c_lo = lo; }\n  }\n  if (!(best <= lattice.tolerance)) { material_uncertain = true; }\n  return d_mul(d_add(D(site, 0.0), D(c_hi, c_lo)), scale);\n}\nfn material_at(p: vec2<f32>) -> u32 {\n  var u = lattice_point(p.x, D(lattice.scale_u_hi, lattice.scale_u_lo), 0u);\n  var v = lattice_point(p.y, D(lattice.scale_v_hi, lattice.scale_v_lo), 1u);\n  if (lattice.placed != 0u) {\n    let k = D(lattice.chart_k_hi, lattice.chart_k_lo);\n    u = d_mul(u, k); v = d_mul(v, k);\n    if (!(le(babs(bd(u)), bx(1.0)) && le(babs(bd(v)), bc(lattice.chart_aspect)))) { return lattice.surround; }\n  }\n  return material(vec4<f32>(u.h, u.l, v.h, v.l));\n}\n`;\n}\n\n/** A fixed-size chart's placement for the module: chart-local frame units per frame unit (m/h) and the chart's aspect. */\nexport interface DisplayViewChartPlacement { chartUnitsPerFrameUnit: number; aspect: number }\n\n/** The lattice constants of a render (see the module comment): the uniform words and the offsets table. */\nexport interface DisplayViewLatticeConstants { params: ArrayBuffer; offsets: Float32Array<ArrayBuffer>; tolerance: number; scaleU: number; scaleV: number }\n\n/**\n * The query lattice of an expected-signal input as the module needs it, or an `unsupported-on-backend` error: the scale per\n * axis from the reference's own query points (two sites a frame apart), the model (x + c)·scale checked against the reference\n * at the frame's four corners for every offset within 2⁻⁴⁸·(|p| + 1), the offsets as hi + lo pairs, and the recovery tolerance\n * 8E·max|x + c| + 2⁻¹², which the distinct fractional parts of the offsets must clear four times over.\n */\nexport function displayViewLatticeConstants(signalInput: DisplayViewExpectedSignalInput, placement: DisplayViewChartPlacement | null, surroundMaterial: number): DisplayViewLatticeConstants {\n  const W = signalInput.nativeWidth, H = signalInput.nativeHeight, offsets = signalInput.offsets, query = signalInput.queryPoint;\n  if (!query) throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"The expected signal has no query points (the Quality path); use cpu-reference.\");\n  if (offsets.length < 1 || offsets.length > DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS) throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"The kernel holds 1 to \" + DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS + \" query offsets.\");\n  if (!(W >= 2 && H >= 2 && W <= 2 ** 20 && H <= 2 ** 20)) throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"The native frame is outside the lattice recovery's range (2 to 2^20 sites per axis).\");\n  const point = new Float64Array(2), x1 = W - 1, y1 = H - 1;\n  query(0, 0, 0, point); const u0 = point[0]!, v0 = point[1]!;\n  query(x1, 0, 0, point); const u1 = point[0]!;\n  query(0, y1, 0, point); const v1 = point[1]!;\n  const scaleU = (u1 - u0) / x1, scaleV = (v1 - v0) / y1;\n  if (!(Number.isFinite(scaleU) && Number.isFinite(scaleV) && scaleU !== 0 && scaleV !== 0)) throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"The request's query lattice has no scale; use cpu-reference.\");\n  const cu = new Float64Array(offsets.length), cv = new Float64Array(offsets.length);\n  let smax = 0;\n  for (let o = 0; o < offsets.length; o++) {\n    const offset = offsets[o]!;\n    cu[o] = 0.5 + offset.x - W / 2; cv[o] = 0.5 + offset.y - H / 2;\n    smax = Math.max(smax, Math.abs(cu[o]!), Math.abs(x1 + cu[o]!), Math.abs(cv[o]!), Math.abs(y1 + cv[o]!));\n    for (const [x, y] of [[0, 0], [x1, 0], [0, y1], [x1, y1]] as const) {\n      query(x, y, o, point);\n      const mu = (x + cu[o]!) * scaleU, mv = (y + cv[o]!) * scaleV;\n      if (!(Math.abs(mu - point[0]!) <= MODEL_TOLERANCE * (Math.abs(point[0]!) + 1) && Math.abs(mv - point[1]!) <= MODEL_TOLERANCE * (Math.abs(point[1]!) + 1)))\n        throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"The request's query points are not a rectilinear site lattice within 2^-48; use cpu-reference.\");\n    }\n  }\n  const tolerance = Math.fround(8 * E * smax + 2 ** -12);\n  if (!(tolerance < 1 / 8)) throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"The query lattice is too wide for the exact point recovery; use cpu-reference.\");\n  // Distinct fractional parts of the offsets must be told apart on the device: more than four tolerances apart, or an exact integer apart (the same lattice).\n  for (const axis of [cu, cv]) {\n    for (let a = 0; a < axis.length; a++) for (let b = a + 1; b < axis.length; b++) {\n      const delta = axis[a]! - axis[b]!, fractional = Math.abs(delta - Math.round(delta));\n      if (fractional !== 0 && !(fractional > 4 * tolerance))\n        throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"Two query offsets are too close (mod one site) for the exact point recovery; use cpu-reference.\");\n    }\n  }\n  const params = new ArrayBuffer(4 * DISPLAY_VIEW_LATTICE.words), floats = new Float32Array(params), words = new Uint32Array(params);\n  const [suH, suL] = dwSplit(scaleU), [svH, svL] = dwSplit(scaleV);\n  floats[DISPLAY_VIEW_LATTICE.scaleUHi] = suH; floats[DISPLAY_VIEW_LATTICE.scaleULo] = suL; floats[DISPLAY_VIEW_LATTICE.scaleVHi] = svH; floats[DISPLAY_VIEW_LATTICE.scaleVLo] = svL;\n  if (placement) {\n    const [kH, kL] = dwSplit(placement.chartUnitsPerFrameUnit);\n    if (!(Number.isFinite(kH) && kH > 0 && Number.isFinite(placement.aspect) && placement.aspect > 0)) throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"The chart placement is not finite.\");\n    floats[DISPLAY_VIEW_LATTICE.chartKHi] = kH; floats[DISPLAY_VIEW_LATTICE.chartKLo] = kL; floats[DISPLAY_VIEW_LATTICE.chartAspect] = placement.aspect;\n  }\n  floats[DISPLAY_VIEW_LATTICE.tolerance] = tolerance;\n  words[DISPLAY_VIEW_LATTICE.offsets] = offsets.length; words[DISPLAY_VIEW_LATTICE.placed] = placement ? 1 : 0; words[DISPLAY_VIEW_LATTICE.surround] = surroundMaterial;\n  words[DISPLAY_VIEW_LATTICE.zero] = 0; // the rounding barrier's zero (`lattice.zero`)\n  const table = new Float32Array(4 * offsets.length);\n  for (let o = 0; o < offsets.length; o++) {\n    const [uH, uL] = dwSplit(cu[o]!), [vH, vL] = dwSplit(cv[o]!);\n    table[4 * o] = uH; table[4 * o + 1] = uL; table[4 * o + 2] = vH; table[4 * o + 3] = vL;\n  }\n  return { params, offsets: table, tolerance, scaleU, scaleV };\n}\n\n/** The resolved scene behind a GPU setup: the chart whose geometry is packed, the layers (or null) and the materials the kernel indexes. */\nfunction sceneOf(gpu: DisplayViewGpuSetup): { chart: ResolvedChartScene; layers: ResolvedChartMaterialLayers | null; materials: ResolvedChartScene[\"materials\"]; key: object } {\n  if (gpu.layers) return { chart: gpu.layers.chart, layers: gpu.layers, materials: gpu.layers.materials, key: gpu.layers };\n  if (gpu.chart) return { chart: gpu.chart, layers: null, materials: gpu.chart.materials, key: gpu.chart };\n  throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"The GPU material lookup covers chart presets, composite charts and declared material-layers scenes; a caller scene function runs on cpu-reference (describe it as material-layers).\");\n}\n\ninterface UploadedRecords { key: object; scope: GpuResourceScope; af: GPUBuffer; ai: GPUBuffer; packed: PackedChartScene }\n\n/**\n * The material modules of one display-view renderer (one device): the chart-preset module for the eight 2.0 presets filling\n * the frame, the composite module for everything else the chart kernels classify. The composite module's device probe runs\n * once per renderer (single flight; a refusal is retried on the next render), its scene records are uploaded once per scene\n * and the four most recent kept until `release()`.\n */\nexport interface DisplayViewMaterialModules {\n  /** The module of a setup's scene, or an `unsupported-on-backend` error (a caller function scene, a failed probe, a materials mismatch). */\n  moduleFor(gpu: DisplayViewGpuSetup, signal: AbortSignal): Promise<DisplayViewGpuMaterialModule>;\n  /** Uploaded scenes (for tests). */\n  readonly uploadedScenes: number;\n  release(): void;\n}\n\nexport function createDisplayViewMaterialModules(runtime: WebGpuRuntime, pipelines: PipelineSource): DisplayViewMaterialModules {\n  const presets = new WeakMap<ResolvedChartScene, DisplayViewGpuMaterialModule>(), uploads: UploadedRecords[] = [];\n  let probed: Promise<ChartCompositeProbeRecord> | null = null;\n  const wgsl = new Map<ChartCompositeProductPath, string>();\n  const probe = (signal: AbortSignal): Promise<ChartCompositeProbeRecord> => {\n    probed ??= probeChartCompositeDevice(runtime, pipelines, signal).catch((error: unknown) => { probed = null; throw error; });\n    return probed;\n  };\n  const records = (scene: ReturnType<typeof sceneOf>): UploadedRecords => {\n    const index = uploads.findIndex((e) => e.key === scene.key);\n    if (index >= 0) { const [entry] = uploads.splice(index, 1); uploads.push(entry!); return entry!; }\n    // packChartScene reads the plan's chart, layers and materials only.\n    const packed = packChartScene({ chart: scene.chart, layers: scene.layers, materials: scene.materials } as unknown as ChartRadianceBatchPlan);\n    if (Math.max(packed.af.byteLength, packed.ai.byteLength) > runtime.maximumStorageBindingBytes) throw new ImageKernelExecutionError(\"insufficient-limits\", \"Chart records exceed the device's storage binding limit.\");\n    const scope = new GpuResourceScope(runtime);\n    const entry: UploadedRecords = { key: scene.key, scope, af: scope.upload(\"photivra-display-view-chart-floats\", packed.af, BUFFER_USAGE.STORAGE), ai: scope.upload(\"photivra-display-view-chart-records\", packed.ai, BUFFER_USAGE.STORAGE), packed };\n    uploads.push(entry);\n    while (uploads.length > KEPT_SCENES) uploads.shift()!.scope.release();\n    return entry;\n  };\n  return {\n    async moduleFor(gpu, signal): Promise<DisplayViewGpuMaterialModule> {\n      const scene = sceneOf(gpu), placement = gpu.placement ?? null, signalInput = gpu.signalInput;\n      const tableMaterials = signalInput.scene.kind === \"materials\" ? signalInput.scene.materials.length : -1;\n      if (tableMaterials !== scene.materials.length + (placement ? 1 : 0))\n        throw new ImageKernelExecutionError(\"unsupported-on-backend\", \"The expected signal's materials do not match the scene's (\" + tableMaterials + \" against \" + scene.materials.length + (placement ? \" plus the surround\" : \"\") + \"); use cpu-reference.\");\n      if (!scene.layers && !placement && chartGpuPresetCode({ chart: scene.chart } as unknown as ChartRadianceBatchPlan) !== undefined) {\n        let module = presets.get(scene.chart);\n        if (!module) { module = chartPresetMaterialModule(scene.chart); presets.set(scene.chart, module); }\n        return module;\n      }\n      const record = await probe(signal), path = record.productPath ?? \"dekker\";\n      const lattice = displayViewLatticeConstants(signalInput, placement, scene.materials.length), uploaded = records(scene);\n      let code = wgsl.get(path);\n      if (code === undefined) { code = chartCompositeMaterialWgsl(path); wgsl.set(path, code); }\n      return { id: chartCompositeMaterialModuleId(path), wgsl: code, compositeProbe: record, bindings: [\n        { binding: 0, kind: \"storage\", buffer: uploaded.af }, { binding: 1, kind: \"storage\", buffer: uploaded.ai },\n        { binding: 2, kind: \"uniform\", data: new Uint8Array(lattice.params) }, { binding: 3, kind: \"storage\", data: lattice.offsets }] };\n    },\n    get uploadedScenes(): number { return uploads.length; },\n    release(): void { for (const entry of uploads.splice(0)) entry.scope.release(); }\n  };\n}\n"]}

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

@@ -0,0 +1,185 @@
+/**
+ * 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:
+ * 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.
+ *
+ * Defocus (#492 step 2c): out of focus the expected signal carries the defocus disc (or each node's diffraction kernel
+ * convolved with it) as site kernels, up to radius 96. The site pass then reads a factored table, sums in blocks, and reads a
+ * lattice whose uncertain points the host resolved with the reference's own material lookup; a band's site pass is split over
+ * dispatches of at most `DISPLAY_VIEW_QUALITY_SITE_TAPS_PER_DISPATCH` taps. A defocused Speed request runs these passes with
+ * its bilinear demosaic (docs/WEBGPU.md, "Defocus on the GPU").
+ *
+ * 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.
+ *
+ * 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, a non-finite output) are recomputed with the
+ * reference, so they are exact. Every stage's wall-clock time is reported (`stageMilliseconds`); on a software adapter it
+ * is not GPU performance.
+ */
+import { type DisplayViewRenderResult, type DisplayViewSetup } from "../facade/display-view.js";
+import { type DisplayViewExpectedSignalInput } from "../facade/expected-signal.js";
+import type { DisplayViewGpuSetup } from "../facade/display-view.js";
+import { type DisplayViewMaterialModules } from "./display-view-composite-material-module.js";
+import { type DisplayViewGpuConformanceCase, type DisplayViewGpuRenderer, type DisplayViewGpuRendererFactory, type DisplayViewGpuRequest } from "../facade/display-view-gpu.js";
+import { type DisplayViewGpuMaterialModule } from "./display-view-speed-gpu.js";
+import { type ImageKernelExecution, type ImageKernelRelativeErrorBound } from "./image-kernel-execution.js";
+import { type WebGpuRuntime } from "./webgpu-runtime.js";
+type PipelineSource = (label: string, code: string) => Promise<GPUComputePipeline>;
+type YieldControl = ((signal: AbortSignal) => Promise<void>) | undefined;
+/**
+ * Largest site-kernel radius the gather takes: the diffraction cap (32 sites) plus the defocus disc's (64 sites), the largest
+ * combined radius the reference builds (#492; `buildExpectedSignalInput`).
+ */
+export declare const DISPLAY_VIEW_QUALITY_MAXIMUM_KERNEL_RADIUS = 96;
+/**
+ * Default largest number of taps one site-pass dispatch gathers (sites × taps per site), so that a band of a large defocus
+ * kernel (up to 150 544 taps per site at radius 96) is split over several dispatches instead of one long one that an operating
+ * system's GPU watchdog could reset (Windows' default TDR delay is 2 s). A choice, not a measurement: 2³⁰ taps take 0.1 s at an
+ * assumed 10¹⁰ taps per second; at radius 94 it leaves about 7 100 sites (111 workgroups) per dispatch, fewer than a large GPU
+ * runs at once. In focus a band stays one dispatch (400 taps per site at f/8). The hardware run of #475 records the site pass's
+ * time and dispatch count (`stageMilliseconds.sites`, `siteDispatches`), which decide whether the budget or a gather split over
+ * several invocations per site is needed.
+ */
+export declare const DISPLAY_VIEW_QUALITY_SITE_TAPS_PER_DISPATCH: number;
+/** What a GPU render of a Quality display view needs: the reference's own setup and expected-signal input, plus the material module. */
+export interface DisplayViewQualityGpuInput {
+    setup: DisplayViewSetup;
+    signalInput: DisplayViewExpectedSignalInput;
+    material: DisplayViewGpuMaterialModule;
+    /** Recompute flagged display pixels with the reference. Default true. */
+    recomputeFlagged?: boolean;
+    /** The states this renderer holds for the setup's correction key (grown by the render); a fresh store when absent. */
+    states?: CorrectionStateStore;
+    /**
+     * #492: sum each site's taps in blocks (rows, groups; `DISPLAY_VIEW_QUALITY_SITES_BLOCKED_WGSL`), whose bound grows with the
+     * kernel's width rather than its tap count. Default: when the setup's expected signal carries the defocus disc
+     * (`setup.gpu.defocusRadius` > 0); in focus the tap-list pass runs as before.
+     */
+    blockedSum?: boolean;
+    /** Largest taps (sites × taps per site) per site-pass dispatch; default `DISPLAY_VIEW_QUALITY_SITE_TAPS_PER_DISPATCH`. */
+    maximumSiteTapsPerDispatch?: number;
+}
+/** Wall-clock milliseconds per stage of one render (upload, dispatch and readback of each pass; host work apart). */
+export interface DisplayViewQualityStageTimings {
+    /** Pass 1: the lattice materials (the material module per lattice point). */
+    lattice: number;
+    /** Pass 2: the site electrons through the combined kernels, the readout moments and the white clip. */
+    sites: number;
+    /** Pass 3: the display pixels (demosaic candidates, development, covariance, correction), every dispatch of it. */
+    pixels: number;
+    /** The low-signal correction states computed on the host (the reference's own draws) and the table uploads. */
+    states: number;
+    /** The host finishing (quantization term, noise draw, Cholesky, encode) of every display pixel. */
+    finishing: number;
+    /** The reference's recomputation of flagged display pixels. */
+    recompute: number;
+    /** Pass 3 dispatches that were repeated because a correction state was missing. */
+    pixelRedispatches: number;
+    /** Pass 2 dispatches (one per band, or more where a band's sites × taps exceed the tap budget per dispatch, #492). */
+    siteDispatches: number;
+}
+/** A GPU Quality display view of one region: the reference's result fields plus the execution label, the bounds, the flags and the timings. */
+export interface DisplayViewQualityGpuResult extends DisplayViewRenderResult {
+    execution: ImageKernelExecution;
+    /** |E_gpu − E_cpu| ≤ relative·|E_cpu| + absolute for every component of every display pixel (linear light); `absolute` is the largest per-pixel term. */
+    expectedValueBound: ImageKernelRelativeErrorBound;
+    /** |V_gpu − V_cpu| ≤ relative·V_cpu + absolute for every covariance entry (linear light squared). */
+    varianceBound: ImageKernelRelativeErrorBound;
+    /** Per display pixel: the absolute terms of the two bounds (the kernel's running bounds, doubled). */
+    expectedValueAbsoluteBound: Float32Array;
+    varianceAbsoluteBound: Float32Array;
+    /** Display pixels (region row-major) the kernel flagged, and those the host recomputed with the reference. */
+    flaggedPixelIndices: Uint32Array;
+    hostRecomputedPixelIndices: Uint32Array;
+    /** The kernel's flag word per display pixel (`DISPLAY_VIEW_QUALITY_FLAG` bits). */
+    pixelFlags: Uint32Array;
+    /** Correction states the render computed on the host (new to the store), and the states the table held at the end. */
+    statesComputed: number;
+    statesHeld: number;
+    /** Taps per native site of the expected-signal gather (over every lattice group). */
+    tapsPerSite: number;
+    /** #492: whether the site pass summed in blocks (the defocus disc), and the relative bound of a site's electrons it used. */
+    blockedSum: boolean;
+    siteSumRelativeBound: number;
+    /**
+     * #492, blocked sum only: lattice points the material module flagged as uncertain that the host resolved with the reference's
+     * own float64 `materialAt` at the reference's lattice point (so no site of a defocused render carries material uncertainty).
+     */
+    latticePointsResolved: number;
+    stageMilliseconds: DisplayViewQualityStageTimings;
+}
+/**
+ * The low-signal correction states a renderer holds for one correction key, as the GPU table reads them: grid keys ascending
+ * with three float32 values each (the host keeps the float64 values; the table is their single rounding).
+ */
+export declare class CorrectionStateStore {
+    #private;
+    get size(): number;
+    has(key: number): boolean;
+    add(gridKeys: Int32Array, values: Float64Array): void;
+    /** The sorted table (rebuilt when states were added since the last call). */
+    table(): {
+        keys: Int32Array<ArrayBuffer>;
+        values: Float32Array<ArrayBuffer>;
+    };
+}
+/**
+ * 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
+ * 2·reach + 2 sites on each axis (so a reflected border site lies in the band's window).
+ */
+export declare function displayViewQualityGpuUnsupportedReason(setup: DisplayViewSetup, signalInput: DisplayViewExpectedSignalInput): string | null;
+/** Renders one region of a Quality display view on the GPU (see the module comment). */
+export declare function renderDisplayViewQualityOnGpu(runtime: WebGpuRuntime, bandBytes: number, input: DisplayViewQualityGpuInput, abort: AbortController, yieldControl: YieldControl, pipelines: PipelineSource): Promise<DisplayViewQualityGpuResult>;
+/**
+ * The GPU setup the material modules read for a Quality render (#491's `createDisplayViewMaterialModules`). The composite module
+ * recovers the exact lattice point from the kernel's float32 point with the request's query offsets and the scale of its own
+ * query points. With diffraction kernels the reference has no query points: it evaluates each lattice group's points with the
+ * lattice formula (p + 0.5 + f − W/2)·g, −(q + 0.5 + f − H/2)·g (`createDisplayViewExpectedSignal`). The lattice pass forms
+ * exactly that point per group, so the module is given the groups as its offsets and that formula as the query points; the
+ * module's own checks (the model at the frame's corners within 2⁻⁴⁸, the offsets' separation, at most 16 offsets) then apply to
+ * them as to a Speed lattice. Without diffraction the request's own offsets and query points are the lattice already (each
+ * group member's point is checked to be its offset's, `displayViewQualityGpuUnsupportedReason`).
+ */
+export declare function qualityMaterialSetup(gpu: DisplayViewGpuSetup): DisplayViewGpuSetup;
+/** The material module of a Quality render's scene (see `qualityMaterialSetup`). */
+export declare function qualityMaterialModule(modules: DisplayViewMaterialModules, gpu: DisplayViewGpuSetup, signal: AbortSignal): Promise<DisplayViewGpuMaterialModule>;
+/**
+ * Why the Quality renderer does not support a prepared request (`DisplayViewGpuRenderer.supports`), or true: engine charts and
+ * declared `material-layers` scenes (the material modules of `createDisplayViewMaterialModules`, #491), the identity or Reinhard
+ * tone curve and at most 64 query offsets (lattice groups). `lens.defocus` out of focus is supported (#492 step 2c: the site pass
+ * gathers the disc, or each node's diffraction kernel convolved with it, up to the reference's own caps of radius 64 and 96);
+ * whether a view's footprints take the exact area mean, whether the device passes the composite probe, and whether the kernel
+ * table fits the device's storage binding limit, is known only per render.
+ */
+export declare function displayViewQualityGpuSupports(request: DisplayViewGpuRequest): true | string;
+/** #479's self-check (see `runQualityConformance`). */
+export declare const DISPLAY_VIEW_QUALITY_CONFORMANCE_CASE: DisplayViewGpuConformanceCase;
+/** #492's self-check of the defocus disc's blocked site sum (see `runQualityConformance`). */
+export declare const DISPLAY_VIEW_QUALITY_DEFOCUS_CONFORMANCE_CASE: DisplayViewGpuConformanceCase;
+/**
+ * The 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.
+ */
+export declare function createDisplayViewGpuRenderer(runtime: WebGpuRuntime, options?: {
+    maximumBandBytes?: number;
+    yieldControl?: YieldControl;
+}): DisplayViewGpuRenderer;
+/** The factory `prepareDisplayView` creates the renderer with (one per device): the Speed and Quality kernels behind one renderer. */
+export declare const displayViewGpuRendererFactory: DisplayViewGpuRendererFactory;
+/** Registers the combined renderer as the display view's GPU renderer and returns the factory registered before. */
+export declare function registerDisplayViewGpuRenderer(): DisplayViewGpuRendererFactory | null;
+export {};