@photivra/engine 2.9.0 → 2.10.0

package/dist/facade/display-view.js

@@ -35,6 +35,7 @@
 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";
+import { InvalidConfigurationError } from "../core/configuration-error.js";
 import { portableCbrt, portableCosTwoPi, portableExp, portableExp2, portableLog2, portablePow } from "../core/portable-math.js";
 /** Stream IDs of the display view's two seeded streams, distinct from the native charge (0) and read-noise (1) streams. */
 export const DISPLAY_VIEW_JITTER_STREAM_ID = 32;
@@ -296,10 +297,175 @@ const ahdStateCache = new Map();
 function correctionKey(seed, correction, perElectron, constantVariance, gains, clipLevel, matrix, toneCurve) {
     return [seed, correction.drawsPerState, ...perElectron, ...constantVariance, ...correction.labMatrix.flat(), ...gains, clipLevel, ...matrix.flat(), toneCurve].join(",");
 }
+/**
+ * Internal (exported for tests, #442): the window offset of each slot, slot (dy + reach)·(2·reach + 1) + dx + reach, as
+ * two integer tables: dx[slot] = (slot mod side) − reach and dy[slot] = ⌊slot / side⌋ − reach. The render loop reads them
+ * instead of taking a modulo and a division per site read; they are the same integers.
+ */
+export function displayViewSlotOffsets(reach) {
+    const side = 2 * reach + 1, slotsCount = side * side;
+    return { dx: Int32Array.from({ length: slotsCount }, (_, slot) => (slot % side) - reach), dy: Int32Array.from({ length: slotsCount }, (_, slot) => ((slot / side) | 0) - reach) };
+}
+/**
+ * Internal (exported for tests, #442): the nested per-phase tables [phase][candidate] (and [channel]) as flat arrays holding
+ * the same typed arrays. Plain arrays of typed arrays with one element kind keep the render loop's keyed loads on one hidden
+ * class each, where the nested arrays (arrays of arrays of typed arrays) made V8 deoptimize the render loop. Every phase must
+ * have the same number of candidates, 1 or 2 (the record layout and the choice variance assume it), each with 3 channels.
+ */
+export function flatDisplayViewCandidateTables(slots, weights, dense, list) {
+    const count = slots[0]?.length ?? 0;
+    if (slots.length !== 4 || (count !== 1 && count !== 2))
+        throw new InvalidConfigurationError("display view: each of the 4 CFA phases needs 1 or 2 demosaic candidates.");
+    const denseAt = [], listAt = [], slotsAt = [], weightsAt = [];
+    for (let p = 0; p < 4; p++) {
+        if (slots[p].length !== count || weights[p]?.length !== count || dense[p]?.length !== count || list[p]?.length !== count)
+            throw new InvalidConfigurationError("display view: every CFA phase needs the same number of demosaic candidates.");
+        for (let d = 0; d < count; d++) {
+            if (slots[p][d].length !== 3 || weights[p][d].length !== 3)
+                throw new InvalidConfigurationError("display view: each demosaic candidate needs a kernel per camera channel.");
+            denseAt[p * 2 + d] = dense[p][d];
+            listAt[p * 2 + d] = list[p][d];
+            for (let c = 0; c < 3; c++) {
+                slotsAt[(p * 2 + d) * 3 + c] = slots[p][d][c];
+                weightsAt[(p * 2 + d) * 3 + c] = weights[p][d][c];
+            }
+        }
+    }
+    return { count, denseAt, listAt, slotsAt, weightsAt };
+}
 /** Internal (exported for tests): the correction states kept across calls, and clearing them. */
 export function displayViewCorrectionStateCount() { let n = 0; for (const states of ahdStateCache.values())
     n += states.index.size; return n; }
 export function clearDisplayViewCorrectionStates() { ahdStateCache.clear(); }
+/** Number of grid keys: AHD_KEY_LEVELS³ (a grid key is (i0·AHD_KEY_LEVELS + i1)·AHD_KEY_LEVELS + i2). */
+const AHD_GRID_KEY_COUNT = AHD_KEY_LEVELS * AHD_KEY_LEVELS * AHD_KEY_LEVELS;
+/** Internal (#447): the correction key of a setup, or null without the AHD correction (the key `renderDisplayView` looks its states up with). */
+export function displayViewCorrectionKey(setup) {
+    if (!setup.ahdCorrection)
+        return null;
+    return correctionKey(setup.seed, setup.ahdCorrection, Float64Array.from(setup.readout, (r) => r.perElectron), Float64Array.from(setup.readout, (r) => r.constantVariance), setup.gains, setup.clipLevel, setup.matrix, setup.toneCurve);
+}
+/** True for a typed array of the named kind from any realm (a structured clone arrives as one of the receiving realm). */
+function isTypedArray(value, tag) {
+    return ArrayBuffer.isView(value) && Object.prototype.toString.call(value) === "[object " + tag + "]";
+}
+/** A grid-key list, checked: an Int32Array of keys in [0, AHD_KEY_LEVELS³). */
+function checkGridKeys(gridKeys, caller) {
+    if (!isTypedArray(gridKeys, "Int32Array"))
+        throw new InvalidConfigurationError(caller + ": gridKeys must be an Int32Array.");
+    const keys = gridKeys;
+    for (let i = 0; i < keys.length; i++)
+        if (!(keys[i] >= 0 && keys[i] < AHD_GRID_KEY_COUNT))
+            throw new InvalidConfigurationError(caller + ": gridKeys[" + i + "] (" + keys[i] + ") is not a grid key, an integer in [0, " + AHD_GRID_KEY_COUNT + ").");
+    return keys;
+}
+/**
+ * 2.10 (#447): the AHD low-signal correction states this JavaScript realm holds (a Web Worker, a page), one entry per cached
+ * setup, least recently used first, each state's grid key and three values copied out. Another realm adds them with
+ * {@link bindDisplayViewCorrectionStates}; a render there then reads them instead of computing them, with the same bytes.
+ */
+export function serializeDisplayViewCorrectionStates() {
+    const out = [];
+    for (const [key, states] of ahdStateCache) {
+        const gridKeys = new Int32Array(states.index.size), values = new Float64Array(3 * states.index.size);
+        let i = 0;
+        for (const [gridKey, n] of states.index) {
+            gridKeys[i] = gridKey;
+            values[3 * i] = states.values[3 * n];
+            values[3 * i + 1] = states.values[3 * n + 1];
+            values[3 * i + 2] = states.values[3 * n + 2];
+            i++;
+        }
+        out.push({ key, gridKeys, values });
+    }
+    return out;
+}
+/**
+ * 2.10 (#447): adds states another realm computed (an export, or `computeCorrectionStates` results) to this realm's cache and
+ * returns the number of states added. For each entry, the grid keys its setup does not hold yet are appended; known ones are
+ * left as they are (a state's values follow from its key, so they are equal). Every entry is checked before the cache is
+ * touched: `key` a non-empty string, `gridKeys` an Int32Array of grid keys, `values` a Float64Array of 3 × `gridKeys.length`
+ * finite numbers; otherwise it fails with an InvalidConfigurationError and the cache is unchanged. The cache's bounds apply as
+ * in a render: an unknown key creates a setup and can evict the least recently used of the four kept, and a setup that
+ * reaches 65 536 states is cleared before the next one is added. Import only keys a prepared view reported
+ * (`correctionKey()`), so states a render here will read.
+ */
+export function bindDisplayViewCorrectionStates(entries) {
+    const caller = "bindDisplayViewCorrectionStates";
+    if (!Array.isArray(entries))
+        throw new InvalidConfigurationError(caller + ": entries must be an array of { key, gridKeys, values }.");
+    const checked = [];
+    for (let e = 0; e < entries.length; e++) {
+        const entry = entries[e], at = caller + ": entries[" + e + "]";
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            throw new InvalidConfigurationError(at + " must be an object { key, gridKeys, values }.");
+        for (const field of Object.keys(entry))
+            if (field !== "key" && field !== "gridKeys" && field !== "values")
+                throw new InvalidConfigurationError(at + " has unknown field " + JSON.stringify(field) + ".");
+        const { key, gridKeys, values } = entry;
+        if (typeof key !== "string" || key.length === 0)
+            throw new InvalidConfigurationError(at + ".key must be a non-empty string (a prepared view's correctionKey()).");
+        const keys = checkGridKeys(gridKeys, at);
+        if (!isTypedArray(values, "Float64Array"))
+            throw new InvalidConfigurationError(at + ".values must be a Float64Array.");
+        const v = values;
+        if (v.length !== 3 * keys.length)
+            throw new InvalidConfigurationError(at + ".values must hold 3 values per grid key (" + 3 * keys.length + "), not " + v.length + ".");
+        for (let i = 0; i < v.length; i++)
+            if (!Number.isFinite(v[i]))
+                throw new InvalidConfigurationError(at + ".values[" + i + "] (" + v[i] + ") is not finite.");
+        checked.push({ key, gridKeys: keys, values: v });
+    }
+    let appended = 0;
+    for (const entry of checked) {
+        const states = correctionStates(entry.key);
+        for (let i = 0; i < entry.gridKeys.length; i++) {
+            const gridKey = entry.gridKeys[i];
+            if (states.index.has(gridKey))
+                continue;
+            // As gridCorrection stores a state.
+            if (states.index.size >= AHD_STATE_LIMIT)
+                states.index.clear();
+            const n = states.index.size;
+            if (states.values.length < 3 * (n + 1)) {
+                const grown = new Float64Array(2 * states.values.length);
+                grown.set(states.values);
+                states.values = grown;
+            }
+            states.values[3 * n] = entry.values[3 * i];
+            states.values[3 * n + 1] = entry.values[3 * i + 1];
+            states.values[3 * n + 2] = entry.values[3 * i + 2];
+            states.index.set(gridKey, n);
+            appended++;
+        }
+    }
+    return appended;
+}
+/**
+ * Internal (#447, `PreparedDisplayView.computeCorrectionStates`): computes the states of the given grid keys for a setup (each
+ * as a render computes it, read from the cache where it is held) and stores them in this realm's cache; returns each key's
+ * three values in the order given. Yields to the host and checks for abort between states, as a render does.
+ */
+export async function computeDisplayViewCorrectionStates(setup, gridKeys) {
+    const keys = checkGridKeys(gridKeys, "computeCorrectionStates");
+    setup.checkAbort();
+    const key = displayViewCorrectionKey(setup), states = correctionStates(key), gridCorrection = createGridCorrection(setup, states);
+    const outKeys = Int32Array.from(keys), values = new Float64Array(3 * keys.length);
+    let lastYield = Date.now();
+    for (let i = 0; i < keys.length; i++) {
+        const gridKey = keys[i], i2 = gridKey % AHD_KEY_LEVELS, i1 = ((gridKey - i2) / AHD_KEY_LEVELS) % AHD_KEY_LEVELS, i0 = (gridKey - i1 * AHD_KEY_LEVELS - i2) / (AHD_KEY_LEVELS * AHD_KEY_LEVELS);
+        const at = gridCorrection(i0, i1, i2);
+        values[3 * i] = states.values[at];
+        values[3 * i + 1] = states.values[at + 1];
+        values[3 * i + 2] = states.values[at + 2];
+        if (Date.now() - lastYield >= 8) {
+            await setup.yieldControl();
+            setup.checkAbort();
+            lastYield = Date.now();
+        }
+    }
+    return { key, gridKeys: outKeys, values };
+}
 /** The state map of one setup (moved to the most recently used end). */
 function correctionStates(key) {
     let states = ahdStateCache.get(key);
@@ -328,77 +494,22 @@ const PIXEL_MEMO_LIMIT = 1 << 16;
  * 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;
+/** Most entries of the site ring (a native site's value, material and readout moments, kept across the display pixels of a render). */
+const SITE_RING_LIMIT = 1 << 18;
 /** 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). */
-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);
-    const expected = new Float64Array(pixelCount * 3), noiseStd = new Float64Array(pixelCount * 3);
-    const columns = Array.from({ length: region.width }, (_, i) => axisSums((region.x + i) * sx, (region.x + i + 1) * sx, frameWidth, margin));
+/**
+ * The state computer of one setup's AHD correction (#447: shared by the render and `computeDisplayViewCorrectionStates`):
+ * gridCorrection(i0, i1, i2) returns the offset of the grid state's three values in `states.values`, computing and storing
+ * the state on first use. The code and its operations are those the render ran in place before.
+ */
+function createGridCorrection(setup, states) {
+    const { seed, ahdCorrection } = setup;
+    const k = Float64Array.from(setup.readout, (r) => r.perElectron), c0 = Float64Array.from(setup.readout, (r) => r.constantVariance);
     const M = setup.matrix, m00 = M[0][0], m01 = M[0][1], m02 = M[0][2], m10 = M[1][0], m11 = M[1][1], m12 = M[1][2], m20 = M[2][0], m21 = M[2][1], m22 = M[2][2];
     const g0 = setup.gains[0], g1 = setup.gains[1], g2 = setup.gains[2], L = setup.clipLevel, reinhard = setup.toneCurve === "positive-reinhard-per-channel";
-    const k = setup.readout.map((r) => r.perElectron), dark = setup.readout.map((r) => r.darkElectrons), c0 = setup.readout.map((r) => r.constantVariance);
-    // Site window: 3 × 3 for the bilinear kernels, 7 × 7 when AHD's candidates read up to 3 sites away. Slot (dy + r)·(2r + 1) + dx + r.
-    const candidates = setup.candidates ?? setup.demosaic.map((phase) => [phase]);
-    const reach = Math.max(1, ...candidates.flat(3).map((t) => Math.max(Math.abs(t.dx), Math.abs(t.dy)))), side = 2 * reach + 1, slotsCount = side * side;
-    const slotOf = (t) => (t.dy + reach) * side + t.dx + reach;
-    // Per phase: the bilinear kernels (for the site variance of each channel), the candidates, and the slots they read.
-    const phaseSlots = [], phaseWeights = [], phaseW2 = [], phaseList = [];
-    const candidateSlots = [], candidateWeights = [], candidateDense = [], candidateList = [];
-    for (let p = 0; p < 4; p++) {
-        const kernels = setup.demosaic[p];
-        phaseSlots[p] = kernels.map((list) => Int32Array.from(list, slotOf));
-        phaseWeights[p] = kernels.map((list) => Float64Array.from(list, (t) => t.weight));
-        phaseW2[p] = Float64Array.from(kernels, (list) => list.reduce((sum, t) => sum + t.weight * t.weight, 0));
-        candidateSlots[p] = candidates[p].map((candidate) => candidate.map((list) => Int32Array.from(list, slotOf)));
-        candidateDense[p] = candidates[p].map((candidate) => { const dense = new Float64Array(3 * slotsCount); candidate.forEach((list, c) => { for (const t of list) {
-            const i = c * slotsCount + slotOf(t);
-            dense[i] = dense[i] + t.weight;
-        } }); return dense; });
-        candidateWeights[p] = candidates[p].map((candidate) => candidate.map((list) => Float64Array.from(list, (t) => t.weight)));
-        const used = new Set([...phaseSlots[p].flatMap((a) => Array.from(a)), ...candidateSlots[p].flat().flatMap((a) => Array.from(a))]);
-        phaseList[p] = Int32Array.from([...used].sort((a, b) => a - b));
-        // The slots of phaseList (same order) where a candidate has a non-zero weight in some channel. A sum over phaseList adds
-        // ±0 at the other slots, which leaves a sum that starts at +0 unchanged, so the sums below skip them.
-        candidateList[p] = candidateDense[p].map((dense) => phaseList[p].filter((slot) => dense[slot] !== 0 || dense[slotsCount + slot] !== 0 || dense[2 * slotsCount + slot] !== 0));
-    }
-    const siteElectrons = new Float64Array(slotsCount), siteMean = new Float64Array(slotsCount), siteVar = new Float64Array(slotsCount), siteThird = new Float64Array(slotsCount), siteChannel = new Int32Array(slotsCount), clip = new Float64Array(3), B = new Float64Array(4), C = new Float64Array(9);
-    const cm = new Float64Array(3), cv = new Float64Array(3), csv = new Float64Array(3), bm = new Float64Array(3), bv = new Float64Array(3), bs = new Float64Array(3);
-    const hm = new Float64Array(3), hv = new Float64Array(3), hs = new Float64Array(3), an = new Float64Array(9);
-    const reach2 = CLIP_REACH_SIGMA * CLIP_REACH_SIGMA;
-    // AHD low-signal correction: an 11 × 11 noisy neighbourhood (AHD reads up to 5 sites away) and the local AHD steps.
-    const ahdCorrection = setup.ahdCorrection, windowReach = ahdCorrection ? Math.max(reach, AHD_REACH) : reach;
-    const correction = new Float64Array(3), patch = new Float64Array(AHD_SIDE * AHD_SIDE), cmAverage = new Float64Array(3);
-    let correctedPixels = 0;
-    const readStd = c0.map((v) => Math.sqrt(v));
-    // The correction of a flat neighbourhood whose sites of channel c have normalized mean μ_c, on a logarithmic grid of states
-    // (AHD_KEY_STEPS per octave from 2^-AHD_KEY_OCTAVES of white); each grid state is computed once with draws seeded by the state
-    // alone, so it is the same in every display pixel and region, and a pixel interpolates trilinearly between the 8 states
-    // around its own channel means.
-    // Grid states are shared across display pixels and across calls: a state depends only on its indices and on the inputs in
-    // `correctionKey` (the seed, the draws, the readout scale and noise, the homogeneity matrix and the development), so a cached
-    // state is the same value the draws would give again.
-    const states = ahdCorrection ? correctionStates(correctionKey(seed, ahdCorrection, k, c0, setup.gains, L, M, setup.toneCurve)) : { index: new Map(), values: new Float64Array(0) };
+    const correction = new Float64Array(3), patch = new Float64Array(AHD_SIDE * AHD_SIDE);
+    const readStd = Float64Array.from(c0, (v) => Math.sqrt(v));
     /** The offset of a grid state's three values in states.values (computed and stored on first use). */
     function gridCorrection(i0, i1, i2) {
         const key = (i0 * AHD_KEY_LEVELS + i1) * AHD_KEY_LEVELS + i2, cached = states.index.get(key);
@@ -433,29 +544,7 @@ export async function renderDisplayView(setup) {
         states.index.set(key, n);
         return 3 * n;
     }
-    const interpolated = new Float64Array(3);
-    const gridBase = new Float64Array(3), gridFrac = new Float64Array(3);
-    function flatCorrection(m0, m1, m2) {
-        for (let i = 0; i < 3; i++) {
-            const m = i === 0 ? m0 : i === 1 ? m1 : m2, g = (portableLog2(Math.min(1, Math.max(AHD_KEY_FLOOR, m))) + AHD_KEY_OCTAVES) * AHD_KEY_STEPS;
-            const base = Math.min(Math.floor(g), AHD_KEY_OCTAVES * AHD_KEY_STEPS - 1);
-            gridBase[i] = base;
-            gridFrac[i] = g - base;
-        }
-        interpolated.fill(0);
-        for (let corner = 0; corner < 8; corner++) {
-            let weight = 1;
-            for (let i = 0; i < 3; i++)
-                weight *= (corner >> i) & 1 ? gridFrac[i] : 1 - gridFrac[i];
-            if (weight === 0)
-                continue;
-            const at = gridCorrection(gridBase[0] + (corner & 1), gridBase[1] + ((corner >> 1) & 1), gridBase[2] + ((corner >> 2) & 1)), value = states.values;
-            for (let comp = 0; comp < 3; comp++)
-                interpolated[comp] = interpolated[comp] + weight * value[at + comp];
-        }
-        return interpolated;
-    }
-    const lab = ahdCorrection?.labMatrix ?? [[1, 0, 0], [0, 1, 0], [0, 0, 1]], labWhite = lab.map((row) => row[0] + row[1] + row[2]);
+    const lab = ahdCorrection.labMatrix, labWhite = Float64Array.from(lab, (row) => row[0] + row[1] + row[2]);
     const l00 = lab[0][0], l01 = lab[0][1], l02 = lab[0][2], l10 = lab[1][0], l11 = lab[1][1], l12 = lab[1][2], l20 = lab[2][0], l21 = lab[2][1], l22 = lab[2][2];
     const lw0 = labWhite[0], lw1 = labWhite[1], lw2 = labWhite[2];
     const gh = new Float64Array(49), gv = new Float64Array(49), cand = [new Float64Array(75), new Float64Array(75)], labs = [new Float64Array(75), new Float64Array(75)];
@@ -547,9 +636,134 @@ export async function renderDisplayView(setup) {
         for (let c = 0; c < 3; c++)
             out[c] = out[c] - linear[c] / 2;
     }
+    return gridCorrection;
+}
+/** Renders the display view (docs/DISPLAY_VIEW.md). */
+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);
+    const expected = new Float64Array(pixelCount * 3), noiseStd = new Float64Array(pixelCount * 3);
+    const columns = Array.from({ length: region.width }, (_, i) => axisSums((region.x + i) * sx, (region.x + i + 1) * sx, frameWidth, margin));
+    const M = setup.matrix, m00 = M[0][0], m01 = M[0][1], m02 = M[0][2], m10 = M[1][0], m11 = M[1][1], m12 = M[1][2], m20 = M[2][0], m21 = M[2][1], m22 = M[2][2];
+    const g0 = setup.gains[0], g1 = setup.gains[1], g2 = setup.gains[2], L = setup.clipLevel, reinhard = setup.toneCurve === "positive-reinhard-per-channel";
+    // Small per-render tables as Float64Arrays (#442): the same doubles as plain arrays, with one element kind for the keyed loads.
+    const k = Float64Array.from(setup.readout, (r) => r.perElectron), dark = Float64Array.from(setup.readout, (r) => r.darkElectrons), c0 = Float64Array.from(setup.readout, (r) => r.constantVariance);
+    // Site window: 3 × 3 for the bilinear kernels, 7 × 7 when AHD's candidates read up to 3 sites away. Slot (dy + r)·(2r + 1) + dx + r.
+    const candidates = setup.candidates ?? setup.demosaic.map((phase) => [phase]);
+    const reach = Math.max(1, ...candidates.flat(3).map((t) => Math.max(Math.abs(t.dx), Math.abs(t.dy)))), side = 2 * reach + 1, slotsCount = side * side;
+    const slotOf = (t) => (t.dy + reach) * side + t.dx + reach;
+    const { dx: slotDx, dy: slotDy } = displayViewSlotOffsets(reach);
+    // Per phase: the bilinear kernels (for the site variance of each channel), the candidates, and the slots they read.
+    const phaseSlots = [], phaseWeights = [], phaseW2 = [], phaseList = [];
+    const candidateSlots = [], candidateWeights = [], candidateDense = [], candidateList = [];
+    for (let p = 0; p < 4; p++) {
+        const kernels = setup.demosaic[p];
+        phaseSlots[p] = kernels.map((list) => Int32Array.from(list, slotOf));
+        phaseWeights[p] = kernels.map((list) => Float64Array.from(list, (t) => t.weight));
+        phaseW2[p] = Float64Array.from(kernels, (list) => list.reduce((sum, t) => sum + t.weight * t.weight, 0));
+        candidateSlots[p] = candidates[p].map((candidate) => candidate.map((list) => Int32Array.from(list, slotOf)));
+        candidateDense[p] = candidates[p].map((candidate) => { const dense = new Float64Array(3 * slotsCount); candidate.forEach((list, c) => { for (const t of list) {
+            const i = c * slotsCount + slotOf(t);
+            dense[i] = dense[i] + t.weight;
+        } }); return dense; });
+        candidateWeights[p] = candidates[p].map((candidate) => candidate.map((list) => Float64Array.from(list, (t) => t.weight)));
+        const used = new Set([...phaseSlots[p].flatMap((a) => Array.from(a)), ...candidateSlots[p].flat().flatMap((a) => Array.from(a))]);
+        phaseList[p] = Int32Array.from([...used].sort((a, b) => a - b));
+        // The slots of phaseList (same order) where a candidate has a non-zero weight in some channel. A sum over phaseList adds
+        // ±0 at the other slots, which leaves a sum that starts at +0 unchanged, so the sums below skip them.
+        candidateList[p] = candidateDense[p].map((dense) => phaseList[p].filter((slot) => dense[slot] !== 0 || dense[slotsCount + slot] !== 0 || dense[2 * slotsCount + slot] !== 0));
+    }
+    // The same tables flat (phase·2 + candidate, ·3 + channel), read by the sample loop below.
+    const { count: candidateCount, denseAt, listAt, slotsAt, weightsAt } = flatDisplayViewCandidateTables(candidateSlots, candidateWeights, candidateDense, candidateList);
+    const siteElectrons = new Float64Array(slotsCount), siteMean = new Float64Array(slotsCount), siteVar = new Float64Array(slotsCount), siteThird = new Float64Array(slotsCount), siteChannel = new Int32Array(slotsCount), clip = new Float64Array(3), B = new Float64Array(4), C = new Float64Array(9);
+    const cm = new Float64Array(3), cv = new Float64Array(3), csv = new Float64Array(3), bm = new Float64Array(3), bv = new Float64Array(3), bs = new Float64Array(3);
+    const hm = new Float64Array(3), hv = new Float64Array(3), hs = new Float64Array(3), an = new Float64Array(9);
+    const reach2 = CLIP_REACH_SIGMA * CLIP_REACH_SIGMA;
+    // Site ring (#441, exact path with filled windows only): a native site's expected electrons, chart material and readout moments depend on the
+    // site alone, so they are computed once per render and kept for the region's native columns (plus the reach) in a ring of
+    // native rows, a power of two holding two display rows' footprints and their reach. An entry is valid while its stamp is
+    // its row + 1 (negated when the window did not track materials, so a material read in one mode is never used in the other).
+    // The ~27 (AHD) or ~7 (bilinear) sites a real pixel reads are copied from the ring instead of being read through the
+    // signal and clipped again for each real pixel that shares them; the signal's window is still told which of its sites were
+    // read (markReads), so its lookup count is the count reading them would give.
+    const siteX0 = Math.max(0, Math.floor(region.x * sx) + margin - reach), siteX1 = Math.min(nativeWidth - 1, Math.ceil((region.x + region.width) * sx) - 1 + margin + reach), siteW = siteX1 - siteX0 + 1;
+    let siteRows = 1;
+    while (siteRows < 2 * Math.ceil(sy) + 2 + 2 * reach)
+        siteRows *= 2;
+    // Coarse (stratified) views read a few scattered real pixels per display pixel, where the ring measured slower; windows
+    // without diffraction kernels read their sites from the signal's own direct ring, cheaply enough that the ring measured
+    // 2–4 % slower there (Speed, #441). Both keep the per-read path below.
+    const siteMask = siteRows - 1, ringCapacity = siteRows * siteW, ringUsable = exactView && ringCapacity <= SITE_RING_LIMIT;
+    // Allocated at the first display pixel that uses the ring (a render whose windows never fill allocates nothing).
+    let ringStamp = new Int32Array(0), ringStatStamp = ringStamp, ringMat = ringStamp, siteSlotQ = ringStamp, siteSlotStamp = ringStamp, markX = ringStamp, markY = ringStamp, markM = ringStamp;
+    let ringV = new Float64Array(0), ringMean = ringV, ringVar = ringV, ringThird = ringV, markV = ringV;
+    // (No closure assigns them, so they stay locals of the render loop.)
+    // AHD low-signal correction: an 11 × 11 noisy neighbourhood (AHD reads up to 5 sites away) and the local AHD steps.
+    const ahdCorrection = setup.ahdCorrection, windowReach = ahdCorrection ? Math.max(reach, AHD_REACH) : reach;
+    const cmAverage = new Float64Array(3);
+    let correctedPixels = 0;
+    // The correction of a flat neighbourhood whose sites of channel c have normalized mean μ_c, on a logarithmic grid of states
+    // (AHD_KEY_STEPS per octave from 2^-AHD_KEY_OCTAVES of white); each grid state is computed once with draws seeded by the state
+    // alone, so it is the same in every display pixel and region, and a pixel interpolates trilinearly between the 8 states
+    // around its own channel means.
+    // Grid states are shared across display pixels and across calls: a state depends only on its indices and on the inputs in
+    // `correctionKey` (the seed, the draws, the readout scale and noise, the homogeneity matrix and the development), so a cached
+    // state is the same value the draws would give again.
+    // A collect pass (#447) records the grid keys its corrected samples read instead of computing or reading states, and
+    // leaves the cache untouched; its image is discarded.
+    const collect = setup.ahdCollect;
+    const states = ahdCorrection && !collect ? correctionStates(displayViewCorrectionKey(setup)) : { index: new Map(), values: new Float64Array(0) };
+    const gridCorrection = ahdCorrection && !collect ? createGridCorrection(setup, states) : () => 0;
+    const interpolated = new Float64Array(3);
+    const gridBase = new Float64Array(3), gridFrac = new Float64Array(3);
+    function flatCorrection(m0, m1, m2) {
+        for (let i = 0; i < 3; i++) {
+            const m = i === 0 ? m0 : i === 1 ? m1 : m2, g = (portableLog2(Math.min(1, Math.max(AHD_KEY_FLOOR, m))) + AHD_KEY_OCTAVES) * AHD_KEY_STEPS;
+            const base = Math.min(Math.floor(g), AHD_KEY_OCTAVES * AHD_KEY_STEPS - 1);
+            gridBase[i] = base;
+            gridFrac[i] = g - base;
+        }
+        interpolated.fill(0);
+        for (let corner = 0; corner < 8; corner++) {
+            let weight = 1;
+            for (let i = 0; i < 3; i++)
+                weight *= (corner >> i) & 1 ? gridFrac[i] : 1 - gridFrac[i];
+            if (weight === 0)
+                continue;
+            const i0 = gridBase[0] + (corner & 1), i1 = gridBase[1] + ((corner >> 1) & 1), i2 = gridBase[2] + ((corner >> 2) & 1);
+            if (collect) {
+                collect.add((i0 * AHD_KEY_LEVELS + i1) * AHD_KEY_LEVELS + i2);
+                continue;
+            }
+            const at = gridCorrection(i0, i1, i2), value = states.values;
+            for (let comp = 0; comp < 3; comp++)
+                interpolated[comp] = interpolated[comp] + weight * value[at + comp];
+        }
+        return interpolated;
+    }
     /** Normalized site value of a slot: normal with mean k·e and variance k²·e + constant, clipped at the white level (1). */
-    function siteStatistics(slot, c, e) {
-        const kc = k[c], mean = kc * e, variance = kc * kc * e + c0[c], gap = 1 - mean;
+    function siteStatistics(slot) {
+        // The channel and electrons are read from the slot arrays: a double passed to a call that is not inlined is boxed.
+        const c = siteChannel[slot], e = siteElectrons[slot], kc = k[c], mean = kc * e, variance = kc * kc * e + c0[c], gap = 1 - mean;
         // Third cumulant of the normalized value: Poisson electrons have κ₃ = e (read and rounding noise add none).
         siteThird[slot] = kc * kc * kc * e;
         if (gap > 0 && gap * gap > reach2 * variance) {
@@ -630,8 +844,27 @@ export async function renderDisplayView(setup) {
             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 wx0 = Math.floor(vx * sx) + margin - windowReach, wy0 = Math.floor(vy * sy) + margin - windowReach;
+            const wx1 = Math.ceil((vx + 1) * sx) + margin + windowReach, wy1 = Math.ceil((vy + 1) * sy) + margin + windowReach;
+            setup.signal.window(wx0, wy0, wx1, wy1);
+            // The jitter stream is only drawn from by the stratified estimator; the exact path reads no jitter.
+            const jitter = exactView ? undefined : createDeterministicUniformStream(deriveNativeSiteStreamSeedUint32(seed, index, DISPLAY_VIEW_JITTER_STREAM_ID)), tracking = setup.signal.tracksMaterial;
+            const ringOn = ringUsable && setup.signal.marksReads, ringSign = tracking ? 1 : -1;
+            if (ringOn && ringStamp.length === 0) {
+                ringStamp = new Int32Array(ringCapacity);
+                ringStatStamp = new Int32Array(ringCapacity);
+                ringMat = new Int32Array(ringCapacity);
+                ringV = new Float64Array(ringCapacity);
+                ringMean = new Float64Array(ringCapacity);
+                ringVar = new Float64Array(ringCapacity);
+                ringThird = new Float64Array(ringCapacity);
+                siteSlotQ = new Int32Array(slotsCount);
+                siteSlotStamp = new Int32Array(slotsCount);
+                markX = new Int32Array(slotsCount);
+                markY = new Int32Array(slotsCount);
+                markV = new Float64Array(slotsCount);
+                markM = new Int32Array(slotsCount);
+            }
             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;
@@ -662,7 +895,7 @@ export async function renderDisplayView(setup) {
                     y = Math.min(frameHeight - 1, Math.floor(fy)) + margin;
                 }
                 const phase = (y & 1) * 2 + (x & 1), list = phaseList[phase];
-                let material = -2;
+                let material = -2, statistics = false;
                 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;
@@ -677,11 +910,95 @@ export async function renderDisplayView(setup) {
                 // 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)
+                if (!memo && ringOn) {
+                    let marks = 0;
                     for (let li = 0; li < list.length; li++) {
                         const slot = list[li];
                         siteCount++;
-                        let sxs = x + (slot % side) - reach, sys = y + ((slot / side) | 0) - reach;
+                        let sxs = x + slotDx[slot], sys = y + slotDy[slot];
+                        if (sxs < 0)
+                            sxs = -sxs;
+                        else if (sxs >= nativeWidth)
+                            sxs = 2 * nativeWidth - 2 - sxs;
+                        if (sys < 0)
+                            sys = -sys;
+                        else if (sys >= nativeHeight)
+                            sys = 2 * nativeHeight - 2 - sys;
+                        const c = (sys & 1) === 0 ? ((sxs & 1) === 0 ? 0 : 1) : ((sxs & 1) === 0 ? 1 : 2);
+                        siteChannel[slot] = c;
+                        // The site's ring entry, for a site inside the ring's columns and the signal's window (a site outside the window
+                        // is read through the signal, which counts it as it counts any read outside its window).
+                        const rowStamp = ringSign * (sys + 1), q = ringOn && sxs >= siteX0 && sxs <= siteX1 && sxs >= wx0 && sxs < wx1 && sys >= wy0 && sys < wy1 ? (sys & siteMask) * siteW + sxs - siteX0 : -1;
+                        siteSlotQ[slot] = q;
+                        siteSlotStamp[slot] = rowStamp;
+                        let e;
+                        if (q >= 0 && ringStamp[q] === rowStamp) {
+                            // The value and material the signal returned for this site; the window is told it was read (markReads below).
+                            const v = ringV[q], own = ringMat[q];
+                            e = v + dark[c];
+                            markX[marks] = sxs;
+                            markY[marks] = sys;
+                            markV[marks] = v;
+                            markM[marks] = own;
+                            marks++;
+                            if (tracking) {
+                                siteElectrons[slot] = e;
+                                material = material === -2 || material === own ? own : -1;
+                                continue;
+                            }
+                        }
+                        else {
+                            const v = setup.signal.site(sxs, sys), own = tracking ? setup.signal.uniformMaterial : -1;
+                            e = v + dark[c];
+                            if (q >= 0) {
+                                ringStamp[q] = rowStamp;
+                                ringV[q] = v;
+                                ringMat[q] = own;
+                                ringStatStamp[q] = 0;
+                            }
+                            if (tracking) {
+                                siteElectrons[slot] = e;
+                                material = material === -2 || material === own ? own : -1;
+                                continue;
+                            }
+                        }
+                        if (q >= 0 && ringStatStamp[q] === rowStamp) {
+                            siteMean[slot] = ringMean[q];
+                            siteVar[slot] = ringVar[q];
+                            siteThird[slot] = ringThird[q];
+                            continue;
+                        }
+                        // As siteStatistics, written out here for the untracked (Speed) path.
+                        const kc = k[c], mean = kc * e, variance = kc * kc * e + c0[c], gap = 1 - mean, third = kc * kc * kc * e;
+                        let sm, sv;
+                        if (gap > 0 && gap * gap > reach2 * variance) {
+                            sm = mean;
+                            sv = variance;
+                        }
+                        else {
+                            upperClip(mean, variance, 1, clip);
+                            sm = clip[0];
+                            sv = clip[1];
+                        }
+                        siteMean[slot] = sm;
+                        siteVar[slot] = sv;
+                        siteThird[slot] = third;
+                        if (q >= 0) {
+                            ringStatStamp[q] = rowStamp;
+                            ringMean[q] = sm;
+                            ringVar[q] = sv;
+                            ringThird[q] = third;
+                        }
+                    }
+                    if (marks > 0)
+                        setup.signal.markReads(markX, markY, markV, markM, marks);
+                }
+                else if (!memo)
+                    for (let li = 0; li < list.length; li++) {
+                        // Without the ring (coarse views, windows without diffraction kernels or with lazy caches): each site through the signal.
+                        const slot = list[li];
+                        siteCount++;
+                        let sxs = x + slotDx[slot], sys = y + slotDy[slot];
                         if (sxs < 0)
                             sxs = -sxs;
                         else if (sxs >= nativeWidth)
@@ -693,11 +1010,18 @@ export async function renderDisplayView(setup) {
                         const c = (sys & 1) === 0 ? ((sxs & 1) === 0 ? 0 : 1) : ((sxs & 1) === 0 ? 1 : 2);
                         const e = setup.signal.site(sxs, sys) + dark[c];
                         siteChannel[slot] = c;
-                        if (tracking) {
+                        if (tracking && !statistics) {
                             siteElectrons[slot] = e;
                             const own = setup.signal.uniformMaterial;
                             material = material === -2 || material === own ? own : -1;
-                            continue;
+                            if (material >= 0)
+                                continue;
+                            // The first site of a second material: the sample is not replayed, so the statistics are taken now, for the earlier
+                            // sites and inline from this site on, instead of in a second pass (#444; each site's statistics depend on its own
+                            // slot only, so the order leaves every value's bits).
+                            statistics = true;
+                            for (let lj = 0; lj < li; lj++)
+                                siteStatistics(list[lj]);
                         }
                         // As siteStatistics, written out here for the untracked (Speed) path.
                         const kc = k[c], mean = kc * e, variance = kc * kc * e + c0[c], gap = 1 - mean;
@@ -724,7 +1048,7 @@ export async function renderDisplayView(setup) {
                         stamps[pk] = stamp;
                     }
                 }
-                const cs = candidateSlots[phase], cw = candidateWeights[phase], count = cs.length, share = 1 / count;
+                const count = candidateCount, share = 1 / count;
                 if (memo) {
                     for (let d = 0; d < count; d++) {
                         for (let c = 0; c < 3; c++) {
@@ -758,11 +1082,48 @@ export async function renderDisplayView(setup) {
                 }
                 // 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)
+                const rt = memoKey >= 0 ? recordScratch : pk >= 0 ? records : undefined, ro = memoKey < 0 && pk >= 0 ? pk * MEMO_SIZE : 0;
+                // Every field of the record (MEMO_SIZE layout) that the propagation below does not write for this sample is zeroed, as a
+                // fill of the whole record would leave it. Always written: [0, 3), [27, 30) and candidate 0's [3, 12) and [21, 24); with
+                // two candidates also candidate 1's [12, 21) and [24, 27) and the choice terms [30, 33); [33, 37) only with the AHD
+                // correction.
+                if (rt) {
+                    if (count === 1) {
+                        for (let o = 12; o < 21; o++)
+                            rt[ro + o] = 0;
+                        rt[ro + 24] = 0;
+                        rt[ro + 25] = 0;
+                        rt[ro + 26] = 0;
+                        rt[ro + 30] = 0;
+                        rt[ro + 31] = 0;
+                        rt[ro + 32] = 0;
+                    }
+                    rt[ro + 33] = 0;
+                    rt[ro + 34] = 0;
+                    rt[ro + 35] = 0;
+                    rt[ro + 36] = 0;
+                }
+                if (tracking && !ringOn) {
+                    if (!statistics)
+                        for (let li = 0; li < list.length; li++)
+                            siteStatistics(list[li]);
+                }
+                else if (tracking)
                     for (let li = 0; li < list.length; li++) {
-                        const slot = list[li];
-                        siteStatistics(slot, siteChannel[slot], siteElectrons[slot]);
+                        const slot = list[li], q = siteSlotQ[slot], rowStamp = siteSlotStamp[slot];
+                        if (q >= 0 && ringStatStamp[q] === rowStamp) {
+                            siteMean[slot] = ringMean[q];
+                            siteVar[slot] = ringVar[q];
+                            siteThird[slot] = ringThird[q];
+                            continue;
+                        }
+                        siteStatistics(slot);
+                        if (q >= 0) {
+                            ringStatStamp[q] = rowStamp;
+                            ringMean[q] = siteMean[slot];
+                            ringVar[q] = siteVar[slot];
+                            ringThird[q] = siteThird[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).
@@ -780,7 +1141,7 @@ export async function renderDisplayView(setup) {
                 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];
+                        const sl = slotsAt[(phase * 2 + d) * 3 + c], wt = weightsAt[(phase * 2 + d) * 3 + c];
                         let mean = 0;
                         for (let t = 0; t < sl.length; t++)
                             mean += wt[t] * siteMean[sl[t]];
@@ -788,7 +1149,7 @@ export async function renderDisplayView(setup) {
                         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];
+                    const dense = denseAt[phase * 2 + d], list = listAt[phase * 2 + 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];
@@ -844,7 +1205,7 @@ export async function renderDisplayView(setup) {
                         }
                         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];
+                            const dense = denseAt[phase * 2 + d], list = listAt[phase * 2 + 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];
@@ -897,7 +1258,8 @@ export async function renderDisplayView(setup) {
                         rt[ro + 22 + d * 3] = t1;
                         rt[ro + 23 + d * 3] = t2;
                     }
-                    pixelVariance = Math.max(pixelVariance, hv[0], hv[1], hv[2]);
+                    // Two-argument maxima (inlined; the same value as one four-argument Math.max, which V8 calls with boxed arguments).
+                    pixelVariance = Math.max(Math.max(pixelVariance, hv[0]), Math.max(hv[1], hv[2]));
                 }
                 s0 += wE * e0;
                 s1 += wE * e1;
@@ -914,7 +1276,7 @@ export async function renderDisplayView(setup) {
                     // 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];
+                    const dh = denseAt[phase * 2], dv = denseAt[phase * 2 + 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]);