@photivra/engine 2.6.0 → 2.8.0

package/dist/facade/display-view.js

@@ -32,7 +32,6 @@
  *    added as independent per-pixel variance, weighted by Σ_j (w_j/A)², as is the output quantization (Δ²/12).
  *    One correlated normal draw per display pixel (the sum of hundreds of independent site noises) gives the noise.
  */
-import { InvalidConfigurationError } from "../core/configuration-error.js";
 import { createDeterministicUniformStream, createPortableStandardNormalPairs, deriveNativeSiteStreamSeedUint32, fmix32, samplePortableStandardNormal } from "../sensor/stochastic-seed.js";
 import { encodeSrgbComponentPortable } from "../color/srgb-transfer.js";
 import { createPoissonSampler } from "../sensor/raw-readout.js";
@@ -41,528 +40,7 @@ import { portableCbrt, portableCosTwoPi, portableExp, portableExp2, portableLog2
 export const DISPLAY_VIEW_JITTER_STREAM_ID = 32;
 export const DISPLAY_VIEW_NOISE_STREAM_ID = 33;
 export const DISPLAY_VIEW_AHD_STREAM_ID = 34;
-const OFFSET_TOLERANCE = 1e-9;
-/** Largest cache window, in sites or lattice points; larger windows are evaluated without caching. */
-const CACHE_LIMIT = 1 << 22;
-/** Largest band of looked-up lattice materials per group, in lattice points (a band that would be larger restarts at the window). */
-const BAND_LIMIT = 1 << 22;
-/**
- * Expected photo electrons per site: μ_c(i, j) = Σ_o w_o Σ_λ A_c(λ) Σ_t K_λ(t)·L(p_o(i, j) − t, λ), where p_o is the
- * query point of offset o and K the diffraction kernel (a single unit tap without diffraction). This is the sum the
- * facade's environment chain forms for a still, rectilinear, distortion-free planar scene, where the
- * radiance-to-irradiance factor is the same at every site (docs/DISPLAY_VIEW.md, "Expected signal").
- *
- * With diffraction, offsets that share a fractional shift read one lattice, and their kernels are combined in advance:
- * C_c(d) = Σ_members w·Σ_λ A_c(λ)·K_λ(t)·L(λ) over the taps t that reach lattice offset d. A neutral material's radiance
- * is its reflectance times the white radiance, so all neutral materials share one combined kernel per channel.
- */
-export function createDisplayViewExpectedSignal(input) {
-    const W = input.nativeWidth, H = input.nativeHeight, g = 2 / input.outputWidth, nodes = input.wavelengthsNm.length;
-    const R = input.kernels ? input.kernels.radius : 0, size = 2 * R + 1;
-    if (input.kernels && input.kernels.perNode.length !== nodes)
-        throw new InvalidConfigurationError("Display view kernels must match the spectral nodes.");
-    if (!input.kernels && !input.queryPoint)
-        throw new InvalidConfigurationError("Display view needs the environment query points without diffraction.");
-    const A = input.electronsPerRadiance, scene = input.scene, offsets = input.offsets, channelAt = input.channelAt;
-    const kernelAt = (node, t) => (input.kernels ? input.kernels.perNode[node][t] : 1);
-    // Materials: neutral ones by reflectance, spectral ones by index.
-    let reflectance = new Float64Array(0), spectralIndex = new Int32Array(0);
-    const spectral = [];
-    if (scene.kind === "materials") {
-        reflectance = new Float64Array(scene.materials.length);
-        spectralIndex = new Int32Array(scene.materials.length).fill(-1);
-        scene.materials.forEach((m, index) => { if ("neutral" in m)
-            reflectance[index] = m.neutral;
-        else {
-            spectralIndex[index] = spectral.length;
-            spectral.push(m.radiance);
-        } });
-    }
-    // Offsets grouped by fractional shift: offsets that differ by whole sites share one lattice.
-    const frac = (v) => { const f = v - Math.floor(v); return f > 1 - OFFSET_TOLERANCE || f < OFFSET_TOLERANCE ? 0 : f; };
-    const groups = [];
-    for (const o of offsets) {
-        const fx = frac(o.x), fy = frac(o.y), ix = Math.round(o.x - fx), iy = Math.round(o.y - fy);
-        let group = groups.find((q) => Math.abs(q.fx - fx) <= OFFSET_TOLERANCE && Math.abs(q.fy - fy) <= OFFSET_TOLERANCE);
-        if (!group) {
-            group = { fx, fy, members: [], minIx: ix, maxIx: ix, minIy: iy, maxIy: iy, cw: 0, ch: 0, neutral: [], spectral: [], perNode: [], cache: new Int32Array(0), cx0: 0, cy0: 0, cpw: 0, cph: 0 };
-            groups.push(group);
-        }
-        group.members.push({ ix, iy, weight: o.weight });
-        group.minIx = Math.min(group.minIx, ix);
-        group.maxIx = Math.max(group.maxIx, ix);
-        group.minIy = Math.min(group.minIy, iy);
-        group.maxIy = Math.max(group.maxIy, iy);
-    }
-    if (input.kernels)
-        for (const group of groups) {
-            // Combined kernel over lattice offsets d = (ix − tu, iy − tv), stored at (d − min + R).
-            const cw = group.maxIx - group.minIx + size, ch = group.maxIy - group.minIy + size;
-            group.cw = cw;
-            group.ch = ch;
-            const combine = (value) => [0, 1, 2].map((c) => {
-                const out = new Float64Array(cw * ch);
-                for (const member of group.members)
-                    for (let tv = -R, t = 0; tv <= R; tv++)
-                        for (let tu = -R; tu <= R; tu++, t++) {
-                            let sum = 0;
-                            for (let n = 0; n < nodes; n++)
-                                sum += value(c, n, t);
-                            const index = (member.iy - tv - group.minIy + R) * cw + (member.ix - tu - group.minIx + R);
-                            out[index] = out[index] + member.weight * sum;
-                        }
-                return out;
-            });
-            if (scene.kind === "materials") {
-                group.neutral = combine((c, n, t) => A[c][n] * kernelAt(n, t) * scene.whiteRadiance[n]);
-                const perMaterial = spectral.map((radiance) => combine((c, n, t) => A[c][n] * kernelAt(n, t) * radiance[n]));
-                group.spectral = [0, 1, 2].map((c) => perMaterial.map((tables) => tables[c]));
-            }
-            else {
-                // Radiance scenes: combined kernels per node, applied to the cached radiance at each node.
-                group.perNode = Array.from({ length: nodes }, (_, n) => combine((c, node, t) => (node === n ? A[c][n] * kernelAt(n, t) : 0)));
-            }
-        }
-    // Neutral tap-0 signal per channel and spectral per material, for the direct (no-kernel) path.
-    const neutralDirect = scene.kind === "materials" ? [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 spectralDirect = [0, 1, 2].map((c) => spectral.map((radiance) => { let s = 0; for (let n = 0; n < nodes; n++)
-        s += A[c][n] * radiance[n]; return s; }));
-    let lookups = 0;
-    const point = new Float64Array(2);
-    const materialSignalDirect = (m, c) => {
-        const si = spectralIndex[m];
-        if (si === undefined)
-            throw new InvalidConfigurationError("Unknown chart material.");
-        return si < 0 ? reflectance[m] * neutralDirect[c] : spectralDirect[c][si];
-    };
-    /** Without diffraction: one site from the environment's own query points. */
-    function directSite(x, y) {
-        const c = channelAt(x, y);
-        let sum = 0;
-        for (let o = 0; o < offsets.length; o++) {
-            input.queryPoint(x, y, o, point);
-            let value;
-            if (scene.kind === "materials") {
-                value = materialSignalDirect(scene.materialAt(point[0], point[1]), c);
-                lookups++;
-            }
-            else {
-                value = 0;
-                for (let n = 0; n < nodes; n++)
-                    value += A[c][n] * scene.radianceAt(point[0], point[1], input.wavelengthsNm[n]);
-                lookups += nodes;
-            }
-            sum += offsets[o].weight * value;
-        }
-        return sum;
-    }
-    // Lattice point (p, q) of a group: the facade's lattice formula (createDiffractedPlanarProvider).
-    const latticeU = (group, p) => (group.fx === 0 ? (p + 0.5 - W / 2) * g : (p + 0.5 + group.fx - W / 2) * g);
-    const latticeV = (group, q) => (group.fy === 0 ? -(q + 0.5 - H / 2) * g : -(q + 0.5 + group.fy - H / 2) * g);
-    const radianceScratch = new Float64Array(nodes);
-    /** Material (or radiance at each node, into radianceScratch) of a group's lattice point, from the window cache when it holds it. */
-    function latticeMaterial(group, p, q) {
-        const i = p - group.cx0, j = q - group.cy0, cached = i >= 0 && j >= 0 && i < group.cpw && j < group.cph;
-        if (cached) {
-            const m = group.cache[j * group.cpw + i];
-            if (m >= 0)
-                return m;
-        }
-        const m = scene.materialAt(latticeU(group, p), latticeV(group, q));
-        lookups++;
-        if (cached)
-            group.cache[j * group.cpw + i] = m;
-        return m;
-    }
-    function latticeRadiance(group, p, q) {
-        const i = p - group.cx0, j = q - group.cy0, cached = i >= 0 && j >= 0 && i < group.cpw && j < group.cph, cache = group.cache;
-        if (cached && !Number.isNaN(cache[(j * group.cpw + i) * nodes])) {
-            for (let n = 0; n < nodes; n++)
-                radianceScratch[n] = cache[(j * group.cpw + i) * nodes + n];
-            return radianceScratch;
-        }
-        const u = latticeU(group, p), v = latticeV(group, q);
-        for (let n = 0; n < nodes; n++)
-            radianceScratch[n] = scene.radianceAt(u, v, input.wavelengthsNm[n]);
-        lookups += nodes;
-        if (cached)
-            for (let n = 0; n < nodes; n++)
-                cache[(j * group.cpw + i) * nodes + n] = radianceScratch[n];
-        return radianceScratch;
-    }
-    /** With diffraction: one site through the combined kernels on each group's lattice. */
-    function kernelSite(x, y) {
-        const c = channelAt(x, y);
-        let sum = 0;
-        for (const group of groups) {
-            const p0 = x + group.minIx - R, q0 = y + group.minIy - R, cw = group.cw, ch = group.ch;
-            if (scene.kind === "materials") {
-                const nk = group.neutral[c], sk = group.spectral[c];
-                for (let dy = 0; dy < ch; dy++)
-                    for (let dx = 0; dx < cw; dx++) {
-                        const m = latticeMaterial(group, p0 + dx, q0 + dy), si = spectralIndex[m];
-                        if (si === undefined)
-                            throw new InvalidConfigurationError("Unknown chart material.");
-                        sum += si < 0 ? reflectance[m] * nk[dy * cw + dx] : sk[si][dy * cw + dx];
-                    }
-            }
-            else {
-                for (let dy = 0; dy < ch; dy++)
-                    for (let dx = 0; dx < cw; dx++) {
-                        const radiance = latticeRadiance(group, p0 + dx, q0 + dy);
-                        for (let n = 0; n < nodes; n++)
-                            sum += group.perNode[n][c][dy * cw + dx] * radiance[n];
-                    }
-            }
-        }
-        return sum;
-    }
-    // Filled windows (chart materials with diffraction, every lattice point of the window cacheable): each group keeps a band of
-    // looked-up lattice materials that covers the window's rows and grows to the right as the windows of a display row move
-    // right, with summed-area tables of material changes. A site whose kernel reads one material only (each group's rectangle
-    // uniform, the same material in all) takes the value of the same sum over that material, precomputed below in the same
-    // order; other sites run the same sum from the band. Either way each site's value is the same sequence of operations as
-    // kernelSite, so it is bit-identical. The scene lookup count stays the count kernelSite's lazy window cache makes (each
-    // cache point a computed site reads counts once per window, points outside the cache once per read): the rectangles of
-    // the sites computed in a window are counted when the window closes (windowLookups).
-    const uniformSite = scene.kind === "materials" && input.kernels ? [0, 1, 2].map((c) => Float64Array.from(scene.materials, (_, m) => {
-        const si = spectralIndex[m];
-        let sum = 0;
-        for (const group of groups) {
-            const nk = group.neutral[c], sk = si < 0 ? nk : group.spectral[c][si];
-            for (let t = 0; t < group.cw * group.ch; t++)
-                sum += si < 0 ? reflectance[m] * nk[t] : sk[t];
-        }
-        return sum;
-    })) : [];
-    const allNeutral = spectral.length === 0;
-    const bands = groups.map(() => ({ x0: 0, y0: 0, rows: 0, capacity: 0, filled: 0, material: new Int32Array(0), reflectance: new Float64Array(0),
-        changeLeft: new Int32Array(0), changeUp: new Int32Array(0), v: new Float64Array(0) }));
-    /** Makes the band of group g cover lattice columns [x0, x1) of rows [y0, y0 + rows), extending it to the right when it can. */
-    function coverBand(g, x0, x1, y0, rows) {
-        const group = groups[g], band = bands[g], materials = scene;
-        if (!(band.rows === rows && band.y0 === y0 && x0 >= band.x0 && x1 - band.x0 <= band.capacity)) {
-            const capacity = Math.max(x1 - x0, Math.min(Math.floor(BAND_LIMIT / rows), W + 2 * (x1 - x0)));
-            const size = rows * capacity, tables = (rows + 1) * (capacity + 1);
-            band.x0 = x0;
-            band.y0 = y0;
-            band.rows = rows;
-            band.capacity = capacity;
-            band.filled = 0;
-            if (band.material.length < size) {
-                band.material = new Int32Array(size);
-                band.reflectance = new Float64Array(allNeutral ? size : 0);
-            }
-            if (band.changeLeft.length < tables) {
-                band.changeLeft = new Int32Array(tables);
-                band.changeUp = new Int32Array(tables);
-            }
-            band.changeLeft.fill(0, 0, capacity + 1);
-            band.changeUp.fill(0, 0, capacity + 1);
-            for (let j = 0; j < rows; j++) {
-                band.changeLeft[(j + 1) * (capacity + 1)] = 0;
-                band.changeUp[(j + 1) * (capacity + 1)] = 0;
-            }
-            if (band.v.length < rows)
-                band.v = new Float64Array(rows);
-            for (let j = 0; j < rows; j++)
-                band.v[j] = latticeV(group, y0 + j);
-        }
-        const stride = band.capacity, S1 = stride + 1, material = band.material, left = band.changeLeft, up = band.changeUp;
-        for (let i = band.filled; i < x1 - band.x0; i++) {
-            const u = latticeU(group, band.x0 + i);
-            for (let j = 0; j < rows; j++) {
-                const m = materials.materialAt(u, band.v[j]);
-                if (spectralIndex[m] === undefined)
-                    throw new InvalidConfigurationError("Unknown chart material.");
-                material[j * stride + i] = m;
-                if (allNeutral)
-                    band.reflectance[j * stride + i] = reflectance[m];
-                const changedLeft = i > 0 && material[j * stride + i - 1] !== m ? 1 : 0, changedUp = j > 0 && material[(j - 1) * stride + i] !== m ? 1 : 0;
-                left[(j + 1) * S1 + i + 1] = left[j * S1 + i + 1] + left[(j + 1) * S1 + i] - left[j * S1 + i] + changedLeft;
-                up[(j + 1) * S1 + i + 1] = up[j * S1 + i + 1] + up[(j + 1) * S1 + i] - up[j * S1 + i] + changedUp;
-            }
-        }
-        band.filled = Math.max(band.filled, x1 - band.x0);
-    }
-    const rectSum = (sat, S1, i0, j0, i1, j1) => sat[j1 * S1 + i1] - sat[j0 * S1 + i1] - sat[j1 * S1 + i0] + sat[j0 * S1 + i0];
-    let filled = false;
-    /** Sites outside the site window computed in this window (x, y pairs in window coordinates); their rectangles count when the window closes. */
-    let outsideSites = [];
-    let marks = new Uint8Array(0), cover = new Uint8Array(0);
-    /** A site of a filled window: (i, j) are its coordinates in the site window, inside or outside it. */
-    function filledSite(x, y, i, j) {
-        const c = channelAt(x, y), inside = i >= 0 && j >= 0 && i < sw && j < sh;
-        if (inside) {
-            let m = -1;
-            for (let g = 0; g < groups.length; g++) {
-                const group = groups[g], band = bands[g], S1 = band.capacity + 1, bi = x + group.minIx - R - band.x0, bj = y + group.minIy - R - band.y0;
-                if (rectSum(band.changeLeft, S1, bi + 1, bj, bi + group.cw, bj + group.ch) !== 0 || rectSum(band.changeUp, S1, bi, bj + 1, bi + group.cw, bj + group.ch) !== 0) {
-                    m = -2;
-                    break;
-                }
-                const own = band.material[bj * band.capacity + bi];
-                if (m === -1)
-                    m = own;
-                else if (own !== m) {
-                    m = -2;
-                    break;
-                }
-            }
-            if (m >= 0) {
-                lastMaterial = m;
-                return uniformSite[c][m];
-            }
-        }
-        lastMaterial = -1;
-        let sum = 0;
-        for (let g = 0; g < groups.length; g++) {
-            const group = groups[g], band = bands[g], cw = group.cw, ch = group.ch, nk = group.neutral[c], sk = group.spectral[c], stride = band.capacity;
-            const p0 = x + group.minIx - R, q0 = y + group.minIy - R, bi = p0 - band.x0, bj = q0 - band.y0;
-            if (inside && allNeutral) {
-                const refl = band.reflectance;
-                for (let dy = 0, t = 0; dy < ch; dy++) {
-                    const row = (bj + dy) * stride + bi;
-                    for (let dx = 0; dx < cw; dx++, t++)
-                        sum += refl[row + dx] * nk[t];
-                }
-            }
-            else if (inside) {
-                const material = band.material;
-                for (let dy = 0, t = 0; dy < ch; dy++) {
-                    const row = (bj + dy) * stride + bi;
-                    for (let dx = 0; dx < cw; dx++, t++) {
-                        const m = material[row + dx], si = spectralIndex[m];
-                        sum += si < 0 ? reflectance[m] * nk[t] : sk[si][t];
-                    }
-                }
-            }
-            else {
-                for (let dy = 0; dy < ch; dy++)
-                    for (let dx = 0; dx < cw; dx++) {
-                        const ci = i + dx, cj = j + dy;
-                        let m;
-                        if (ci >= 0 && cj >= 0 && ci < group.cpw && cj < group.cph)
-                            m = band.material[(bj + dy) * stride + bi + dx];
-                        else
-                            m = scene.materialAt(latticeU(group, p0 + dx), latticeV(group, q0 + dy));
-                        const si = spectralIndex[m];
-                        if (si === undefined)
-                            throw new InvalidConfigurationError("Unknown chart material.");
-                        sum += si < 0 ? reflectance[m] * nk[dy * cw + dx] : sk[si][dy * cw + dx];
-                    }
-            }
-        }
-        return sum;
-    }
-    /** Lattice points of an outside site's rectangles that lie outside the window caches (kernelSite looks these up on every read). */
-    function outsideLookups(i, j) {
-        let count = 0;
-        for (const group of groups) {
-            const w = Math.max(0, Math.min(i + group.cw, group.cpw) - Math.max(i, 0)), h = Math.max(0, Math.min(j + group.ch, group.cph) - Math.max(j, 0));
-            count += group.cw * group.ch - w * h;
-        }
-        return count;
-    }
-    // Site values of filled windows persist across windows (a site's value does not depend on the window): rows of native
-    // sites in a ring of a power-of-two number of rows, row y in slot y mod ringRows. The window's site cache still holds the
-    // sites read in the window, which is also what its lookup count needs.
-    let ringRows = 0, ringOn = false, ring = new Float64Array(0), ringMaterial = new Int32Array(0), ringRowId = new Int32Array(0), windowMaterial = new Int32Array(0), lastMaterial = -1;
-    /** A filled-window site read outside the site window: counted as kernelSite counts it. */
-    function outsideRead(i, j) { lookups += outsideLookups(i, j); outsideSites.push(i, j); }
-    /** A site from the ring; on a miss (re)claims the row's slot when another row holds it, computes the site and stores it. */
-    function ringRead(x, y, i, j) {
-        const slot = y & (ringRows - 1), q = slot * W + x;
-        if (ringRowId[slot] === y) {
-            const v = ring[q];
-            if (v === v) {
-                lastMaterial = ringMaterial[q];
-                return v;
-            }
-        }
-        else {
-            ringRowId[slot] = y;
-            ring.fill(NaN, slot * W, (slot + 1) * W);
-        }
-        const v = filledSite(x, y, i, j);
-        ring[q] = v;
-        ringMaterial[q] = lastMaterial;
-        return v;
-    }
-    /** A site not in the window's site cache: from the ring, a filled window without the ring, the lazy window caches, or uncached. */
-    function siteMiss(x, y, i, j, cached) {
-        if (ringOn) {
-            if (!cached) {
-                outsideRead(i, j);
-                return ringRead(x, y, i, j);
-            }
-            const v = ringRead(x, y, i, j);
-            siteCache[j * sw + i] = v;
-            windowMaterial[j * sw + i] = lastMaterial;
-            return v;
-        }
-        if (filled && !cached)
-            outsideRead(i, j);
-        const v = filled ? filledSite(x, y, i, j) : input.kernels ? kernelSite(x, y) : directSite(x, y);
-        if (cached)
-            siteCache[j * sw + i] = v;
-        return v;
-    }
-    /**
-     * Lattice points of the closing window that kernelSite's lazy cache would have looked up: per group, the window cache points
-     * covered by the rectangles of the computed sites (the site cache's filled entries and the outside sites), a box dilation.
-     */
-    function windowLookups() {
-        let total = 0;
-        for (const group of groups) {
-            const cw = group.cw, ch = group.ch, cpw = group.cpw, cph = group.cph, ew = cpw + cw - 1, eh = cph + ch - 1;
-            // Top-left marks in extended coordinates (window coordinates + (cw − 1, ch − 1)), and their bounding box.
-            if (marks.length < ew * eh) {
-                marks = new Uint8Array(ew * eh);
-            }
-            let x0 = ew, x1 = -1, y0 = eh, y1 = -1;
-            const mark = (ei, ej) => {
-                if (ei < 0 || ej < 0 || ei >= ew || ej >= eh)
-                    return;
-                marks[ej * ew + ei] = 1;
-                if (ei < x0)
-                    x0 = ei;
-                if (ei > x1)
-                    x1 = ei;
-                if (ej < y0)
-                    y0 = ej;
-                if (ej > y1)
-                    y1 = ej;
-            };
-            for (let j = 0; j < sh; j++)
-                for (let i = 0; i < sw; i++)
-                    if (!Number.isNaN(siteCache[j * sw + i]))
-                        mark(i + cw - 1, j + ch - 1);
-            for (let k = 0; k < outsideSites.length; k += 2)
-                mark(outsideSites[k] + cw - 1, outsideSites[k + 1] + ch - 1);
-            if (x1 < 0)
-                continue;
-            // Cache point (i, j) is covered when a mark lies in extended columns [i, i + cw) and rows [j, j + ch): a horizontal
-            // then a vertical running count over the marks' box (outside it nothing is covered).
-            const i0 = Math.max(0, x0 - cw + 1), i1 = Math.min(cpw - 1, x1), cwid = i1 - i0 + 1;
-            if (cover.length < cwid * (y1 - y0 + 1))
-                cover = new Uint8Array(cwid * (y1 - y0 + 1));
-            for (let r = y0; r <= y1; r++) {
-                let run = 0;
-                for (let e = i0; e <= i1 + cw - 1; e++) {
-                    run += marks[r * ew + e];
-                    if (e - cw >= i0)
-                        run -= marks[r * ew + e - cw];
-                    if (e >= i0 + cw - 1)
-                        cover[(r - y0) * cwid + e - cw + 1 - i0] = run > 0 ? 1 : 0;
-                }
-                marks.fill(0, r * ew + x0, r * ew + x1 + 1);
-            }
-            for (let i = 0; i < cwid; i++) {
-                let run = 0;
-                for (let r = y0; r <= y1 + ch - 1; r++) {
-                    if (r <= y1)
-                        run += cover[(r - y0) * cwid + i];
-                    if (r - ch >= y0 && r - ch <= y1)
-                        run -= cover[(r - ch - y0) * cwid + i];
-                    const j = r - ch + 1;
-                    if (j >= 0 && j < cph && run > 0)
-                        total++;
-                }
-            }
-        }
-        return total;
-    }
-    let sx0 = 0, sy0 = 0, sw = 0, sh = 0, siteCache = new Float64Array(0);
-    const pilotNode = input.wavelengthsNm[Math.floor(nodes / 2)];
-    return {
-        get lookups() { return lookups + (filled ? windowLookups() : 0); },
-        get uniformMaterial() { return lastMaterial; },
-        get tracksMaterial() { return ringOn; },
-        window(x0, y0, x1, y1) {
-            if (filled)
-                lookups += windowLookups();
-            filled = false;
-            ringOn = false;
-            outsideSites = [];
-            sx0 = x0;
-            sy0 = y0;
-            sw = Math.max(0, x1 - x0);
-            sh = Math.max(0, y1 - y0);
-            if (sw * sh > CACHE_LIMIT) {
-                sw = 0;
-                sh = 0;
-            }
-            if (siteCache.length < sw * sh)
-                siteCache = new Float64Array(sw * sh);
-            siteCache.fill(NaN, 0, sw * sh);
-            if (!input.kernels)
-                return;
-            for (const group of groups) {
-                group.cx0 = x0 + group.minIx - R;
-                group.cy0 = y0 + group.minIy - R;
-                group.cpw = sw === 0 ? 0 : sw + group.cw - 1;
-                group.cph = sh === 0 ? 0 : sh + group.ch - 1;
-                if (group.cpw * group.cph * (scene.kind === "materials" ? 1 : nodes) > CACHE_LIMIT) {
-                    group.cpw = 0;
-                    group.cph = 0;
-                }
-            }
-            // Chart materials whose every group caches the whole window: the filled path (bands). Otherwise the lazy window caches.
-            if (scene.kind === "materials" && sw > 0 && groups.every((group) => group.cpw > 0)) {
-                groups.forEach((group, g) => coverBand(g, group.cx0, group.cx0 + group.cpw, group.cy0, group.cph));
-                filled = true;
-                if (windowMaterial.length < sw * sh)
-                    windowMaterial = new Int32Array(sw * sh);
-                // A ring of at least twice the window's rows keeps the rows of the previous display row's windows.
-                if (ringRows < 2 * sh) {
-                    let rows = 1;
-                    while (rows < 2 * sh)
-                        rows *= 2;
-                    if (rows * W <= CACHE_LIMIT) {
-                        ringRows = rows;
-                        ring = new Float64Array(rows * W).fill(NaN);
-                        ringMaterial = new Int32Array(rows * W);
-                        ringRowId = new Int32Array(rows).fill(-1);
-                    }
-                }
-                ringOn = ringRows >= 2 * sh;
-                return;
-            }
-            for (const group of groups) {
-                const n = group.cpw * group.cph * (scene.kind === "materials" ? 1 : nodes);
-                if (scene.kind === "materials") {
-                    if (group.cache.length < n || !(group.cache instanceof Int32Array))
-                        group.cache = new Int32Array(n);
-                    group.cache.fill(-1, 0, n);
-                }
-                else {
-                    if (group.cache.length < n || !(group.cache instanceof Float64Array))
-                        group.cache = new Float64Array(n);
-                    group.cache.fill(NaN, 0, n);
-                }
-            }
-        },
-        site(x, y) {
-            // The window's site cache first (with the ring: the sites read in this window, which its lookup count needs too).
-            const i = x - sx0, j = y - sy0, cached = i >= 0 && j >= 0 && i < sw && j < sh;
-            if (cached) {
-                const w = j * sw + i, v = siteCache[w];
-                if (v === v) {
-                    if (ringOn)
-                        lastMaterial = windowMaterial[w];
-                    return v;
-                }
-            }
-            return siteMiss(x, y, i, j, cached);
-        },
-        pilot(u, v) {
-            lookups++;
-            return scene.kind === "materials" ? scene.materialAt(u, v) : scene.radianceAt(u, v, pilotNode);
-        }
-    };
-}
+export { createDisplayViewExpectedSignal } from "./expected-signal.js";
 // ---------------------------------------------------------------------------------------------------------------
 // Normal-distribution helpers.
 /** Standard normal density. */
@@ -841,6 +319,15 @@ function correctionStates(key) {
  * AHD choice terms; 33 a 1 when the AHD correction applies and [34, 37) its values.
  */
 const MEMO_SIZE = 37;
+/** Most real pixels a display pixel's footprint may have for the per-real-pixel memo (#392); larger footprints rarely repeat a real pixel. */
+const PIXEL_MEMO_LIMIT = 1 << 16;
+/**
+ * Most real pixels a footprint may hold for the exact area mean (#393). Measured on 8-row strips of a 24 MP view (Siemens star
+ * and dead leaves, one thread): the exact path matched the stratified estimator's time within run-to-run spread up to 25 real
+ * pixels per display pixel and was slower above (1.2× at 36, 1.4–1.5× at 64, 1.5–2.4× at 144), because every real pixel is
+ * evaluated while the stratified estimator takes a quarter of its samples per axis where the pilot finds no detail.
+ */
+export const EXACT_AREA_MEAN_MAX_PIXELS = 25;
 /** Pilot points per axis: about one per two sites of the footprint plus its reach, 4 to 16. */
 function pilotCount(span) { return Math.max(4, Math.min(16, Math.ceil(span / 2))); }
 /** Renders the display view (docs/DISPLAY_VIEW.md). */
@@ -848,6 +335,21 @@ export async function renderDisplayView(setup) {
     const { frameWidth, frameHeight, margin, nativeWidth, nativeHeight, viewWidth, viewHeight, region, seed, reachSites } = setup;
     const sx = frameWidth / viewWidth, sy = frameHeight / viewHeight, area = sx * sy, g = 2 / frameWidth;
     const fullK = setup.samplesPerAxis, uniformK = Math.max(1, Math.round(fullK / 4));
+    // Exact area mean (#393): where a footprint holds at most EXACT_AREA_MEAN_MAX_PIXELS real pixels and at most K², every real
+    // pixel it touches is evaluated once with its exact overlap weight a_j = w_j / A, so the expected value is D_P = Σ_j a_j·E[L_j]
+    // with no sampling error at no more cost than sampling; coarser views keep the stratified estimator, whose cost does not
+    // grow with the footprint.
+    const exactView = area <= Math.min(EXACT_AREA_MEAN_MAX_PIXELS, fullK * fullK);
+    const columnOverlaps = exactView ? Array.from({ length: region.width }, (_, i) => overlaps((region.x + i) * sx, (region.x + i + 1) * sx, frameWidth)) : [];
+    // On the exact path a real pixel's recorded terms are shared by the 2–4 display pixels whose footprints touch it: they are
+    // kept for the region's native columns in a ring of native rows (a power of two, at least twice a footprint's height plus
+    // one), valid while a slot's stamp is its native row + 1.
+    const exactX0 = Math.floor(region.x * sx) + margin, exactWidth = Math.min(frameWidth - 1, Math.ceil((region.x + region.width) * sx) - 1) + margin - exactX0 + 1;
+    let exactRows = 1;
+    while (exactRows < 2 * (Math.ceil(sy) + 1))
+        exactRows *= 2;
+    const exactMemo = exactView && exactRows * exactWidth <= PIXEL_MEMO_LIMIT * 4;
+    const exactStamp = new Int32Array(exactMemo ? exactRows * exactWidth : 0), exactRecords = new Float64Array(exactMemo ? exactRows * exactWidth * MEMO_SIZE : 0);
     const maximum = setup.bitDepth === 8 ? 255 : 65535, step = 1 / maximum;
     const pixelCount = region.width * region.height;
     const samples = setup.bitDepth === 8 ? new Uint8Array(pixelCount * 3) : new Uint16Array(pixelCount * 3);
@@ -1062,7 +564,14 @@ export async function renderDisplayView(setup) {
     }
     let siteCount = 0, sampleCount = 0, detail = 0, uniform = 0, lastYield = Date.now();
     /** Recorded terms of samples whose sites all read one chart material, by material·4 + CFA phase (layout: MEMO_SIZE). */
-    const sampleMemo = new Map();
+    const sampleMemo = new Map(), recordScratch = new Float64Array(MEMO_SIZE);
+    // Per-real-pixel memo (#392): a sample's recorded terms depend only on its real pixel (its sites' expected electrons and its
+    // CFA phase), not on the display pixel or the sample, so a later sample of the same real pixel in the same display pixel
+    // replays them (the same values added to the same sums in the same order, as the one-material memo does). Slots cover the
+    // display pixel's footprint and are valid while their stamp equals the display pixel's generation. A replayed sample still
+    // counts its sites; it is used only where every site lies in the window's site cache, where reading it again would have
+    // cost no work and no scene lookup.
+    let pixelStamp = new Int32Array(0), pixelRecords = new Float64Array(0), pixelGeneration = 0;
     // Pilot: the scene at a deterministic grid over each display pixel's footprint widened by the reach; a pixel is uniform when
     // every point returns the same value. Pixels next to a detailed pixel count as detailed too, so an edge that only clips a
     // footprint's corner (too thin for the grid) still gets the full samples. The grid is fixed, so the sample count is not
@@ -1087,7 +596,8 @@ export async function renderDisplayView(setup) {
     const ringWidth = region.width + 2, flagRows = [];
     const pilotRow = (vy) => {
         const row = new Uint8Array(ringWidth);
-        if (vy < 0 || vy >= viewHeight)
+        // The exact area mean needs no pilot: every pixel evaluates its whole footprint.
+        if (exactView || vy < 0 || vy >= viewHeight)
             return row.fill(1);
         for (let i = 0; i < ringWidth; i++) {
             const vx = region.x - 1 + i;
@@ -1097,7 +607,7 @@ export async function renderDisplayView(setup) {
     };
     flagRows.push(pilotRow(region.y - 1), pilotRow(region.y));
     for (let ry = 0; ry < region.height; ry++) {
-        const vy = region.y + ry, rows = axisSums(vy * sy, (vy + 1) * sy, frameHeight, margin);
+        const vy = region.y + ry, rows = axisSums(vy * sy, (vy + 1) * sy, frameHeight, margin), rowOverlaps = exactView ? overlaps(vy * sy, (vy + 1) * sy, frameHeight) : undefined;
         flagRows.push(pilotRow(vy + 1));
         if (flagRows.length > 3)
             flagRows.shift();
@@ -1112,22 +622,62 @@ export async function renderDisplayView(setup) {
                         break;
                     }
             const K = same ? uniformK : fullK, Q = K * K;
-            if (same)
+            // On the exact path every pixel counts as detailed (its whole footprint is evaluated).
+            if (exactView)
+                detail++;
+            else if (same)
                 uniform++;
             else
                 detail++;
+            const cols = exactView ? columnOverlaps[rx] : undefined, nx = cols ? cols.w.length : 0, sampleTotal = exactView ? nx * rowOverlaps.w.length : Q;
             setup.signal.window(Math.floor(vx * sx) + margin - windowReach, Math.floor(vy * sy) + margin - windowReach, Math.ceil((vx + 1) * sx) + margin + windowReach, Math.ceil((vy + 1) * sy) + margin + windowReach);
             const jitter = createDeterministicUniformStream(deriveNativeSiteStreamSeedUint32(seed, index, DISPLAY_VIEW_JITTER_STREAM_ID)), tracking = setup.signal.tracksMaterial;
+            const mx0 = Math.floor(vx * sx) + margin, my0 = Math.floor(vy * sy) + margin;
+            const mw = Math.min(frameWidth - 1, Math.ceil((vx + 1) * sx)) + margin - mx0 + 1, mh = Math.min(frameHeight - 1, Math.ceil((vy + 1) * sy)) + margin - my0 + 1;
+            const pixelMemo = !exactView && setup.signal.cachesSites && mw * mh <= PIXEL_MEMO_LIMIT;
+            if (pixelMemo) {
+                if (pixelStamp.length < mw * mh) {
+                    pixelStamp = new Int32Array(mw * mh);
+                    pixelRecords = new Float64Array(mw * mh * MEMO_SIZE);
+                    pixelGeneration = 0;
+                }
+                pixelGeneration++;
+            }
             let s0 = 0, s1 = 0, s2 = 0, c00 = 0, c01 = 0, c02 = 0, c11 = 0, c12 = 0, c22 = 0, r0 = 0, r1 = 0, r2 = 0, pixelVariance = 0, corrected = false;
-            for (let b = 0; b < K; b++)
-                for (let a = 0; a < K; a++) {
+            for (let n = 0; n < sampleTotal; n++) {
+                // A sample's weights: 1 for the stratified estimator (its sums are divided by Q below); a_j for the expected value and
+                // linear covariance and a_j² for the independent residual on the exact path. Multiplying by 1 leaves every value's bits.
+                let x, y, wE = 1, wR = 1;
+                if (cols) {
+                    const i = n % nx, j = (n - i) / nx, aj = cols.w[i] * rowOverlaps.w[j] / area;
+                    x = cols.first + i + margin;
+                    y = rowOverlaps.first + j + margin;
+                    wE = aj;
+                    wR = aj * aj;
+                }
+                else {
+                    const a = n % K, b = (n - a) / K;
                     const fx = (vx + (a + jitter.next()) / K) * sx, fy = (vy + (b + jitter.next()) / K) * sy;
-                    const x = Math.min(frameWidth - 1, Math.floor(fx)) + margin, y = Math.min(frameHeight - 1, Math.floor(fy)) + margin;
-                    const phase = (y & 1) * 2 + (x & 1), list = phaseList[phase];
-                    let material = -2;
-                    // The expected electrons of the sites the demosaic reads (sites outside the raster, at mirror borders, are read
-                    // reflect-101); where the signal tracks it, whether they all read one chart material, with the statistics below only
-                    // when the sample is not replayed; otherwise the statistics at once.
+                    x = Math.min(frameWidth - 1, Math.floor(fx)) + margin;
+                    y = Math.min(frameHeight - 1, Math.floor(fy)) + margin;
+                }
+                const phase = (y & 1) * 2 + (x & 1), list = phaseList[phase];
+                let material = -2;
+                const px = x - mx0, py = y - my0;
+                const inside = x >= reach && y >= reach && x + reach < nativeWidth && y + reach < nativeHeight;
+                const stamps = exactMemo ? exactStamp : pixelStamp, records = exactMemo ? exactRecords : pixelRecords, stamp = exactMemo ? y + 1 : pixelGeneration;
+                const pk = exactMemo ? (inside && x >= exactX0 && x - exactX0 < exactWidth ? (y & (exactRows - 1)) * exactWidth + x - exactX0 : -1)
+                    : pixelMemo && px >= 0 && py >= 0 && px < mw && py < mh && inside ? py * mw + px : -1;
+                let memo, mo = 0;
+                if (pk >= 0 && stamps[pk] === stamp) {
+                    memo = records;
+                    mo = pk * MEMO_SIZE;
+                    siteCount += list.length;
+                }
+                // The expected electrons of the sites the demosaic reads (sites outside the raster, at mirror borders, are read
+                // reflect-101); where the signal tracks it, whether they all read one chart material, with the statistics below only
+                // when the sample is not replayed; otherwise the statistics at once.
+                if (!memo)
                     for (let li = 0; li < list.length; li++) {
                         const slot = list[li];
                         siteCount++;
@@ -1162,247 +712,262 @@ export async function renderDisplayView(setup) {
                             siteVar[slot] = clip[1];
                         }
                     }
-                    if (!tracking)
-                        material = -1;
-                    // A sample whose sites all read one chart material only has the statistics of every other such sample of that material
-                    // and CFA phase: replay its recorded terms (the same values added to the same sums in the same order).
-                    const memoKey = material >= 0 ? material * 4 + phase : -1, memo = memoKey >= 0 ? sampleMemo.get(memoKey) : undefined;
-                    const cs = candidateSlots[phase], cw = candidateWeights[phase], count = cs.length, share = 1 / count;
-                    if (memo) {
-                        for (let d = 0; d < count; d++) {
-                            for (let c = 0; c < 3; c++) {
-                                const o = 3 + (d * 3 + c) * 3, a0 = memo[o], a1 = memo[o + 1], a2 = memo[o + 2], wgt = share * B[c] * memo[c];
-                                c00 += wgt * a0 * a0;
-                                c01 += wgt * a0 * a1;
-                                c02 += wgt * a0 * a2;
-                                c11 += wgt * a1 * a1;
-                                c12 += wgt * a1 * a2;
-                                c22 += wgt * a2 * a2;
-                            }
-                            r0 += memo[21 + d * 3];
-                            r1 += memo[22 + d * 3];
-                            r2 += memo[23 + d * 3];
-                        }
-                        s0 += memo[27];
-                        s1 += memo[28];
-                        s2 += memo[29];
-                        if (count === 2) {
-                            r0 += memo[30];
-                            r1 += memo[31];
-                            r2 += memo[32];
-                        }
-                        if (memo[33] === 1) {
-                            s0 += memo[34];
-                            s1 += memo[35];
-                            s2 += memo[36];
-                            corrected = true;
-                        }
-                        continue;
-                    }
-                    const record = memoKey >= 0 ? new Float64Array(MEMO_SIZE) : undefined;
-                    if (tracking)
-                        for (let li = 0; li < list.length; li++) {
-                            const slot = list[li];
-                            siteStatistics(slot, siteChannel[slot], siteElectrons[slot]);
-                        }
-                    // Site variance of each channel through the bilinear kernels (for B_c), then the demosaic's own pixel statistics: the
-                    // mean and covariance of its camera channels, averaged over its candidates (AHD picks one per pixel).
-                    const slots = phaseSlots[phase], weights = phaseWeights[phase], w2 = phaseW2[phase];
-                    for (let c = 0; c < 3; c++) {
-                        const sl = slots[c], wt = weights[c];
-                        let variance = 0;
-                        for (let t = 0; t < sl.length; t++)
-                            variance += wt[t] * wt[t] * siteVar[sl[t]];
-                        csv[c] = variance / w2[c];
+                if (!tracking)
+                    material = -1;
+                // A sample whose sites all read one chart material only has the statistics of every other such sample of that material
+                // and CFA phase: replay its recorded terms (the same values added to the same sums in the same order).
+                const memoKey = !memo && material >= 0 ? material * 4 + phase : -1;
+                if (memoKey >= 0) {
+                    memo = sampleMemo.get(memoKey);
+                    if (memo && pk >= 0) {
+                        records.set(memo, pk * MEMO_SIZE);
+                        stamps[pk] = stamp;
                     }
-                    // Each candidate of the demosaic (one for bilinear; AHD's horizontal and vertical ones, of which AHD picks one per pixel)
-                    // is propagated on its own: camera-channel mean and covariance, white balance and highlight clip, colour matrix and
-                    // rendering; the pixel's statistics are their average.
-                    let e0 = 0, e1 = 0, e2 = 0;
+                }
+                const cs = candidateSlots[phase], cw = candidateWeights[phase], count = cs.length, share = 1 / count;
+                if (memo) {
                     for (let d = 0; d < count; d++) {
                         for (let c = 0; c < 3; c++) {
-                            const sl = cs[d][c], wt = cw[d][c];
-                            let mean = 0;
-                            for (let t = 0; t < sl.length; t++)
-                                mean += wt[t] * siteMean[sl[t]];
-                            cm[c] = mean;
-                            cmAverage[c] = (d === 0 ? 0 : cmAverage[c]) + mean * share;
-                        }
-                        // Covariance of channels i, j: Σ over the sites of w_i·w_j·Var(site), with the kernels as dense weights over the window.
-                        const dense = candidateDense[phase][d], list = candidateList[phase][d];
-                        let v00 = 0, v01 = 0, v02 = 0, v11 = 0, v12 = 0, v22 = 0;
-                        for (let li = 0; li < list.length; li++) {
-                            const slot = list[li], v = siteVar[slot], w0 = dense[slot], w1 = dense[slotsCount + slot], w2 = dense[2 * slotsCount + slot];
-                            v00 += w0 * w0 * v;
-                            v01 += w0 * w1 * v;
-                            v02 += w0 * w2 * v;
-                            v11 += w1 * w1 * v;
-                            v12 += w1 * w2 * v;
-                            v22 += w2 * w2 * v;
-                        }
-                        C[0] = v00;
-                        C[1] = v01;
-                        C[2] = v02;
-                        C[3] = v01;
-                        C[4] = v11;
-                        C[5] = v12;
-                        C[6] = v02;
-                        C[7] = v12;
-                        C[8] = v22;
-                        // White balance and the highlight clip at the smallest gain (per channel; covariances scaled by the expected slopes).
-                        for (let c = 0; c < 3; c++) {
-                            const mean = cm[c], variance = C[c * 4];
-                            cv[c] = variance;
-                            const gc = c === 0 ? g0 : c === 1 ? g1 : g2, um = gc * mean, uv = gc * gc * variance, gap = L - um;
-                            if (gap > 0 && gap * gap > reach2 * uv) {
-                                bm[c] = um;
-                                bv[c] = uv;
-                                bs[c] = gc;
-                            }
-                            else {
-                                upperClip(um, uv, L, clip);
-                                bm[c] = clip[0];
-                                bv[c] = clip[1];
-                                bs[c] = gc * clip[2];
-                            }
-                        }
-                        // Colour matrix, then the rendering of each component (tone curve, clip to [0, 1]).
-                        for (let comp = 0; comp < 3; comp++) {
-                            const r0m = comp === 0 ? m00 : comp === 1 ? m10 : m20, r1m = comp === 0 ? m01 : comp === 1 ? m11 : m21, r2m = comp === 0 ? m02 : comp === 1 ? m12 : m22;
-                            const mean = r0m * bm[0] + r1m * bm[1] + r2m * bm[2];
-                            const variance = r0m * r0m * bv[0] + r1m * r1m * bv[1] + r2m * r2m * bv[2] +
-                                2 * (r0m * r1m * bs[0] * bs[1] * C[1] + r0m * r2m * bs[0] * bs[2] * C[2] + r1m * r2m * bs[1] * bs[2] * C[5]);
-                            if (!reinhard && mean > 0 && mean < 1 && mean * mean > reach2 * variance && (1 - mean) * (1 - mean) > reach2 * variance) {
-                                hm[comp] = mean;
-                                hv[comp] = variance;
-                                hs[comp] = 1;
-                            }
-                            else if (reinhard) {
-                                reinhardMoments(mean, variance, clip);
-                                hm[comp] = clip[0];
-                                hv[comp] = clip[1];
-                                hs[comp] = clip[2];
-                            }
-                            else {
-                                // The component is a linear combination of the sites: κ₃ = Σ (Σ_c M·Γ_c·w_c,site)³·κ₃(site).
-                                const dense = candidateDense[phase][d], list = candidateList[phase][d];
-                                let third = 0;
-                                for (let li = 0; li < list.length; li++) {
-                                    const slot = list[li], coefficient = r0m * bs[0] * dense[slot] + r1m * bs[1] * dense[slotsCount + slot] + r2m * bs[2] * dense[2 * slotsCount + slot];
-                                    third += coefficient * coefficient * coefficient * siteThird[slot];
-                                }
-                                unitClip(mean, variance, clip, variance > 0 ? third / (variance * Math.sqrt(variance)) : 0);
-                                hm[comp] = clip[0];
-                                hv[comp] = clip[1];
-                                hs[comp] = clip[2];
-                            }
-                        }
-                        e0 += share * hm[0];
-                        e1 += share * hm[1];
-                        e2 += share * hm[2];
-                        // Linear (Stein) part: a_c = J ∘ M[:, c]·Γ_c, accumulated with B_c·σ_c² (site variance of channel c); the pixel's own
-                        // linear variance (aᵀ·C·a, full channel covariance) for the residual.
-                        let l0 = 0, l1 = 0, l2 = 0;
-                        for (let c = 0; c < 3; c++) {
-                            const a0 = hs[0] * (c === 0 ? m00 : c === 1 ? m01 : m02) * bs[c], a1 = hs[1] * (c === 0 ? m10 : c === 1 ? m11 : m12) * bs[c], a2 = hs[2] * (c === 0 ? m20 : c === 1 ? m21 : m22) * bs[c];
-                            const wgt = share * B[c] * csv[c];
+                            const o = mo + 3 + (d * 3 + c) * 3, a0 = memo[o], a1 = memo[o + 1], a2 = memo[o + 2], wgt = wE * share * B[c] * memo[mo + c];
                             c00 += wgt * a0 * a0;
                             c01 += wgt * a0 * a1;
                             c02 += wgt * a0 * a2;
                             c11 += wgt * a1 * a1;
                             c12 += wgt * a1 * a2;
                             c22 += wgt * a2 * a2;
-                            an[c] = a0;
-                            an[3 + c] = a1;
-                            an[6 + c] = a2;
-                            if (record) {
-                                const o = 3 + (d * 3 + c) * 3;
-                                record[o] = a0;
-                                record[o + 1] = a1;
-                                record[o + 2] = a2;
-                            }
                         }
-                        for (let i = 0; i < 3; i++)
-                            for (let j = 0; j < 3; j++) {
-                                const cij = C[i * 3 + j];
-                                l0 += an[i] * an[j] * cij;
-                                l1 += an[3 + i] * an[3 + j] * cij;
-                                l2 += an[6 + i] * an[6 + j] * cij;
-                            }
-                        const t0 = share * Math.max(0, hv[0] - l0), t1 = share * Math.max(0, hv[1] - l1), t2 = share * Math.max(0, hv[2] - l2);
-                        r0 += t0;
-                        r1 += t1;
-                        r2 += t2;
-                        if (record) {
-                            record[21 + d * 3] = t0;
-                            record[22 + d * 3] = t1;
-                            record[23 + d * 3] = t2;
-                        }
-                        pixelVariance = Math.max(pixelVariance, hv[0], hv[1], hv[2]);
-                    }
-                    s0 += e0;
-                    s1 += e1;
-                    s2 += e2;
-                    if (record) {
-                        record[0] = csv[0];
-                        record[1] = csv[1];
-                        record[2] = csv[2];
-                        record[27] = e0;
-                        record[28] = e1;
-                        record[29] = e2;
+                        r0 += wR * memo[mo + 21 + d * 3];
+                        r1 += wR * memo[mo + 22 + d * 3];
+                        r2 += wR * memo[mo + 23 + d * 3];
                     }
+                    s0 += wE * memo[mo + 27];
+                    s1 += wE * memo[mo + 28];
+                    s2 += wE * memo[mo + 29];
                     if (count === 2) {
-                        // AHD's per-pixel choice between the candidates adds independent variance: with a noise-driven choice each pixel
-                        // deviates from the candidates' average by ±½(H − V), variance ¼·Var(H − V) (linear in the sites, at the last
-                        // candidate's slopes).
-                        const dh = candidateDense[phase][0], dv = candidateDense[phase][1], list = phaseList[phase];
-                        let x0 = 0, x1 = 0, x2 = 0;
-                        for (let li = 0; li < list.length; li++) {
-                            const slot = list[li], d0 = bs[0] * (dh[slot] - dv[slot]), d1 = bs[1] * (dh[slotsCount + slot] - dv[slotsCount + slot]), d2 = bs[2] * (dh[2 * slotsCount + slot] - dv[2 * slotsCount + slot]);
-                            const v = siteVar[slot], a = hs[0] * (m00 * d0 + m01 * d1 + m02 * d2), b = hs[1] * (m10 * d0 + m11 * d1 + m12 * d2), c = hs[2] * (m20 * d0 + m21 * d1 + m22 * d2);
-                            x0 += a * a * v;
-                            x1 += b * b * v;
-                            x2 += c * c * v;
+                        r0 += wR * memo[mo + 30];
+                        r1 += wR * memo[mo + 31];
+                        r2 += wR * memo[mo + 32];
+                    }
+                    if (memo[mo + 33] === 1) {
+                        s0 += wE * memo[mo + 34];
+                        s1 += wE * memo[mo + 35];
+                        s2 += wE * memo[mo + 36];
+                        corrected = true;
+                    }
+                    continue;
+                }
+                // The terms are written where they are kept: the real pixel's memo slot, or (for the first sample of a one-material key)
+                // a scratch buffer that is then copied; no typed-array view per sample.
+                const rt = memoKey >= 0 ? recordScratch.fill(0) : pk >= 0 ? records.fill(0, pk * MEMO_SIZE, (pk + 1) * MEMO_SIZE) : undefined, ro = memoKey < 0 && pk >= 0 ? pk * MEMO_SIZE : 0;
+                if (tracking)
+                    for (let li = 0; li < list.length; li++) {
+                        const slot = list[li];
+                        siteStatistics(slot, siteChannel[slot], siteElectrons[slot]);
+                    }
+                // Site variance of each channel through the bilinear kernels (for B_c), then the demosaic's own pixel statistics: the
+                // mean and covariance of its camera channels, averaged over its candidates (AHD picks one per pixel).
+                const slots = phaseSlots[phase], weights = phaseWeights[phase], w2 = phaseW2[phase];
+                for (let c = 0; c < 3; c++) {
+                    const sl = slots[c], wt = weights[c];
+                    let variance = 0;
+                    for (let t = 0; t < sl.length; t++)
+                        variance += wt[t] * wt[t] * siteVar[sl[t]];
+                    csv[c] = variance / w2[c];
+                }
+                // Each candidate of the demosaic (one for bilinear; AHD's horizontal and vertical ones, of which AHD picks one per pixel)
+                // is propagated on its own: camera-channel mean and covariance, white balance and highlight clip, colour matrix and
+                // rendering; the pixel's statistics are their average.
+                let e0 = 0, e1 = 0, e2 = 0;
+                for (let d = 0; d < count; d++) {
+                    for (let c = 0; c < 3; c++) {
+                        const sl = cs[d][c], wt = cw[d][c];
+                        let mean = 0;
+                        for (let t = 0; t < sl.length; t++)
+                            mean += wt[t] * siteMean[sl[t]];
+                        cm[c] = mean;
+                        cmAverage[c] = (d === 0 ? 0 : cmAverage[c]) + mean * share;
+                    }
+                    // Covariance of channels i, j: Σ over the sites of w_i·w_j·Var(site), with the kernels as dense weights over the window.
+                    const dense = candidateDense[phase][d], list = candidateList[phase][d];
+                    let v00 = 0, v01 = 0, v02 = 0, v11 = 0, v12 = 0, v22 = 0;
+                    for (let li = 0; li < list.length; li++) {
+                        const slot = list[li], v = siteVar[slot], w0 = dense[slot], w1 = dense[slotsCount + slot], w2 = dense[2 * slotsCount + slot];
+                        v00 += w0 * w0 * v;
+                        v01 += w0 * w1 * v;
+                        v02 += w0 * w2 * v;
+                        v11 += w1 * w1 * v;
+                        v12 += w1 * w2 * v;
+                        v22 += w2 * w2 * v;
+                    }
+                    C[0] = v00;
+                    C[1] = v01;
+                    C[2] = v02;
+                    C[3] = v01;
+                    C[4] = v11;
+                    C[5] = v12;
+                    C[6] = v02;
+                    C[7] = v12;
+                    C[8] = v22;
+                    // White balance and the highlight clip at the smallest gain (per channel; covariances scaled by the expected slopes).
+                    for (let c = 0; c < 3; c++) {
+                        const mean = cm[c], variance = C[c * 4];
+                        cv[c] = variance;
+                        const gc = c === 0 ? g0 : c === 1 ? g1 : g2, um = gc * mean, uv = gc * gc * variance, gap = L - um;
+                        if (gap > 0 && gap * gap > reach2 * uv) {
+                            bm[c] = um;
+                            bv[c] = uv;
+                            bs[c] = gc;
+                        }
+                        else {
+                            upperClip(um, uv, L, clip);
+                            bm[c] = clip[0];
+                            bv[c] = clip[1];
+                            bs[c] = gc * clip[2];
+                        }
+                    }
+                    // Colour matrix, then the rendering of each component (tone curve, clip to [0, 1]).
+                    for (let comp = 0; comp < 3; comp++) {
+                        const r0m = comp === 0 ? m00 : comp === 1 ? m10 : m20, r1m = comp === 0 ? m01 : comp === 1 ? m11 : m21, r2m = comp === 0 ? m02 : comp === 1 ? m12 : m22;
+                        const mean = r0m * bm[0] + r1m * bm[1] + r2m * bm[2];
+                        const variance = r0m * r0m * bv[0] + r1m * r1m * bv[1] + r2m * r2m * bv[2] +
+                            2 * (r0m * r1m * bs[0] * bs[1] * C[1] + r0m * r2m * bs[0] * bs[2] * C[2] + r1m * r2m * bs[1] * bs[2] * C[5]);
+                        if (!reinhard && mean > 0 && mean < 1 && mean * mean > reach2 * variance && (1 - mean) * (1 - mean) > reach2 * variance) {
+                            hm[comp] = mean;
+                            hv[comp] = variance;
+                            hs[comp] = 1;
+                        }
+                        else if (reinhard) {
+                            reinhardMoments(mean, variance, clip);
+                            hm[comp] = clip[0];
+                            hv[comp] = clip[1];
+                            hs[comp] = clip[2];
+                        }
+                        else {
+                            // The component is a linear combination of the sites: κ₃ = Σ (Σ_c M·Γ_c·w_c,site)³·κ₃(site).
+                            const dense = candidateDense[phase][d], list = candidateList[phase][d];
+                            let third = 0;
+                            for (let li = 0; li < list.length; li++) {
+                                const slot = list[li], coefficient = r0m * bs[0] * dense[slot] + r1m * bs[1] * dense[slotsCount + slot] + r2m * bs[2] * dense[2 * slotsCount + slot];
+                                third += coefficient * coefficient * coefficient * siteThird[slot];
+                            }
+                            unitClip(mean, variance, clip, variance > 0 ? third / (variance * Math.sqrt(variance)) : 0);
+                            hm[comp] = clip[0];
+                            hv[comp] = clip[1];
+                            hs[comp] = clip[2];
                         }
-                        r0 += x0 / 4;
-                        r1 += x1 / 4;
-                        r2 += x2 / 4;
-                        if (record) {
-                            record[30] = x0 / 4;
-                            record[31] = x1 / 4;
-                            record[32] = x2 / 4;
+                    }
+                    e0 += share * hm[0];
+                    e1 += share * hm[1];
+                    e2 += share * hm[2];
+                    // Linear (Stein) part: a_c = J ∘ M[:, c]·Γ_c, accumulated with B_c·σ_c² (site variance of channel c); the pixel's own
+                    // linear variance (aᵀ·C·a, full channel covariance) for the residual.
+                    let l0 = 0, l1 = 0, l2 = 0;
+                    for (let c = 0; c < 3; c++) {
+                        const a0 = hs[0] * (c === 0 ? m00 : c === 1 ? m01 : m02) * bs[c], a1 = hs[1] * (c === 0 ? m10 : c === 1 ? m11 : m12) * bs[c], a2 = hs[2] * (c === 0 ? m20 : c === 1 ? m21 : m22) * bs[c];
+                        const wgt = wE * share * B[c] * csv[c];
+                        c00 += wgt * a0 * a0;
+                        c01 += wgt * a0 * a1;
+                        c02 += wgt * a0 * a2;
+                        c11 += wgt * a1 * a1;
+                        c12 += wgt * a1 * a2;
+                        c22 += wgt * a2 * a2;
+                        an[c] = a0;
+                        an[3 + c] = a1;
+                        an[6 + c] = a2;
+                        if (rt) {
+                            const o = 3 + (d * 3 + c) * 3;
+                            rt[ro + o] = a0;
+                            rt[ro + o + 1] = a1;
+                            rt[ro + o + 2] = a2;
                         }
                     }
-                    // AHD at low signal: its homogeneity choice reacts to the noise, which the linear candidates cannot express. A sample
-                    // whose pixel noise exceeds the threshold adds the correction of a flat neighbourhood with its channel means, from the
-                    // shared grid of states (flatCorrection): there AHD and the two linear candidates run on the same drawn neighbourhoods
-                    // and the difference of the rendered results is averaged, a control variate whose expectation is the AHD bias
-                    // (docs/DISPLAY_VIEW.md).
-                    if (ahdCorrection && pixelVariance > ahdCorrection.thresholdVariance) {
-                        const fix = flatCorrection(cmAverage[0], cmAverage[1], cmAverage[2]);
-                        s0 += fix[0];
-                        s1 += fix[1];
-                        s2 += fix[2];
-                        corrected = true;
-                        if (record) {
-                            record[33] = 1;
-                            record[34] = fix[0];
-                            record[35] = fix[1];
-                            record[36] = fix[2];
+                    for (let i = 0; i < 3; i++)
+                        for (let j = 0; j < 3; j++) {
+                            const cij = C[i * 3 + j];
+                            l0 += an[i] * an[j] * cij;
+                            l1 += an[3 + i] * an[3 + j] * cij;
+                            l2 += an[6 + i] * an[6 + j] * cij;
                         }
+                    const t0 = share * Math.max(0, hv[0] - l0), t1 = share * Math.max(0, hv[1] - l1), t2 = share * Math.max(0, hv[2] - l2);
+                    r0 += wR * t0;
+                    r1 += wR * t1;
+                    r2 += wR * t2;
+                    if (rt) {
+                        rt[ro + 21 + d * 3] = t0;
+                        rt[ro + 22 + d * 3] = t1;
+                        rt[ro + 23 + d * 3] = t2;
                     }
-                    if (record)
-                        sampleMemo.set(memoKey, record);
-                    pixelVariance = 0;
+                    pixelVariance = Math.max(pixelVariance, hv[0], hv[1], hv[2]);
                 }
-            sampleCount += Q;
+                s0 += wE * e0;
+                s1 += wE * e1;
+                s2 += wE * e2;
+                if (rt) {
+                    rt[ro + 0] = csv[0];
+                    rt[ro + 1] = csv[1];
+                    rt[ro + 2] = csv[2];
+                    rt[ro + 27] = e0;
+                    rt[ro + 28] = e1;
+                    rt[ro + 29] = e2;
+                }
+                if (count === 2) {
+                    // AHD's per-pixel choice between the candidates adds independent variance: with a noise-driven choice each pixel
+                    // deviates from the candidates' average by ±½(H − V), variance ¼·Var(H − V) (linear in the sites, at the last
+                    // candidate's slopes).
+                    const dh = candidateDense[phase][0], dv = candidateDense[phase][1], list = phaseList[phase];
+                    let x0 = 0, x1 = 0, x2 = 0;
+                    for (let li = 0; li < list.length; li++) {
+                        const slot = list[li], d0 = bs[0] * (dh[slot] - dv[slot]), d1 = bs[1] * (dh[slotsCount + slot] - dv[slotsCount + slot]), d2 = bs[2] * (dh[2 * slotsCount + slot] - dv[2 * slotsCount + slot]);
+                        const v = siteVar[slot], a = hs[0] * (m00 * d0 + m01 * d1 + m02 * d2), b = hs[1] * (m10 * d0 + m11 * d1 + m12 * d2), c = hs[2] * (m20 * d0 + m21 * d1 + m22 * d2);
+                        x0 += a * a * v;
+                        x1 += b * b * v;
+                        x2 += c * c * v;
+                    }
+                    r0 += wR * (x0 / 4);
+                    r1 += wR * (x1 / 4);
+                    r2 += wR * (x2 / 4);
+                    if (rt) {
+                        rt[ro + 30] = x0 / 4;
+                        rt[ro + 31] = x1 / 4;
+                        rt[ro + 32] = x2 / 4;
+                    }
+                }
+                // AHD at low signal: its homogeneity choice reacts to the noise, which the linear candidates cannot express. A sample
+                // whose pixel noise exceeds the threshold adds the correction of a flat neighbourhood with its channel means, from the
+                // shared grid of states (flatCorrection): there AHD and the two linear candidates run on the same drawn neighbourhoods
+                // and the difference of the rendered results is averaged, a control variate whose expectation is the AHD bias
+                // (docs/DISPLAY_VIEW.md).
+                if (ahdCorrection && pixelVariance > ahdCorrection.thresholdVariance) {
+                    const fix = flatCorrection(cmAverage[0], cmAverage[1], cmAverage[2]);
+                    s0 += wE * fix[0];
+                    s1 += wE * fix[1];
+                    s2 += wE * fix[2];
+                    corrected = true;
+                    if (rt) {
+                        rt[ro + 33] = 1;
+                        rt[ro + 34] = fix[0];
+                        rt[ro + 35] = fix[1];
+                        rt[ro + 36] = fix[2];
+                    }
+                }
+                if (rt && memoKey >= 0) {
+                    sampleMemo.set(memoKey, rt.slice());
+                    if (pk >= 0)
+                        records.set(rt, pk * MEMO_SIZE);
+                }
+                if (pk >= 0)
+                    stamps[pk] = stamp;
+                pixelVariance = 0;
+            }
+            sampleCount += sampleTotal;
             if (corrected)
                 correctedPixels++;
-            const mean0 = s0 / Q, mean1 = s1 / Q, mean2 = s2 / Q, pixels = B[3];
+            // Stratified: means over Q samples. Exact: the weights already sum to 1 (Σ a_j = 1) and the residual carries Σ a_j²·r_j.
+            const Qd = exactView ? 1 : Q, mean0 = s0 / Qd, mean1 = s1 / Qd, mean2 = s2 / Qd, pixels = B[3];
             // The real pixels' output rounding (Δ²/12 in the encoded domain), mapped to linear light at the mean.
             const q0 = quantizationVariance(mean0, step), q1 = quantizationVariance(mean1, step), q2 = quantizationVariance(mean2, step);
             // Covariance in linear light: the linear part plus the independent per-pixel residuals and rounding.
-            const v00 = c00 / Q + pixels * (r0 / Q + q0), v01 = c01 / Q, v02 = c02 / Q, v11 = c11 / Q + pixels * (r1 / Q + q1), v12 = c12 / Q, v22 = c22 / Q + pixels * (r2 / Q + q2);
+            const v00 = exactView ? c00 + r0 + pixels * q0 : c00 / Q + pixels * (r0 / Q + q0), v01 = c01 / Qd, v02 = c02 / Qd, v11 = exactView ? c11 + r1 + pixels * q1 : c11 / Q + pixels * (r1 / Q + q1), v12 = c12 / Qd, v22 = exactView ? c22 + r2 + pixels * q2 : c22 / Q + pixels * (r2 / Q + q2);
             const noise = createDeterministicUniformStream(deriveNativeSiteStreamSeedUint32(seed, index, DISPLAY_VIEW_NOISE_STREAM_ID));
             const z0 = samplePortableStandardNormal(noise), z1 = samplePortableStandardNormal(noise), z2 = samplePortableStandardNormal(noise);
             // Cholesky factor of the 3 × 3 covariance (positive semidefinite; tiny negative pivots are treated as 0).
@@ -1422,14 +987,16 @@ export async function renderDisplayView(setup) {
             noiseStd[o] = Math.sqrt(Math.max(0, v00));
             noiseStd[o + 1] = Math.sqrt(Math.max(0, v11));
             noiseStd[o + 2] = Math.sqrt(Math.max(0, v22));
-            if (Date.now() - lastYield >= 8) {
+            // The clock is read every 16 display pixels and at the end of each row (yield timing never changes the output).
+            if (((rx & 15) === 15 || rx === region.width - 1) && Date.now() - lastYield >= 8) {
                 await setup.yieldControl();
                 setup.checkAbort();
                 lastYield = Date.now();
             }
         }
     }
-    return { samples, expected, noiseStd, sampleCount, siteCount, detailPixelCount: detail, uniformPixelCount: uniform, ahdCorrectedPixelCount: correctedPixels };
+    return { samples, expected, noiseStd, sampleCount, siteCount, detailPixelCount: detail, uniformPixelCount: uniform, ahdCorrectedPixelCount: correctedPixels,
+        estimation: exactView ? "exact-area-mean" : "stratified-monte-carlo" };
 }
 /**
  * The centre c of a normal of variance v whose clip to [0, 1] has mean `target` (bisection; c = target when the noise does