@photivra/engine 2.9.0 → 2.11.1

package/dist/facade/simulate-capture.js

@@ -72,9 +72,11 @@ import { createRollingShutterCaptureExposureSchedule, resolveElectronicRollingSh
 import { calculateCaptureExposureWindows } from "../sensor/exposure-window.js";
 import { calculateSensorSpectralQuadrature } from "../sensor/spectral-quadrature.js";
 import { createDiffractionLimitedPsfProfile } from "../optics/diffraction-psf-profile.js";
+import { registerDiffractionPsfKey, siteDiffractionKernel } from "../optics/site-diffraction-kernel.js";
+import { convolveSiteKernels, createDefocusDiscSiteKernel, requireDefocusDiscKernelRadius, resolveDefocusDisc } from "../optics/defocus-disc-kernel.js";
 import { createDiffractedPlanarProvider } from "./diffraction-provider.js";
 import { resolveGenericPrimeLens } from "../equipment/generic-prime-lenses.js";
-import { executeEnvironmentSensorPhotoSignal, planEnvironmentSensorPhotoSignal } from "../sensor/environment-photo-signal.js";
+import { calculateChannelElectronsPerRadiance } from "./channel-response.js";
 import { calculateSiteEffectiveSaturationCode } from "../capture/raw-white-level.js";
 import { prepareSensorColorDevelopment } from "../color/sensor-color-development.js";
 import { resolveAntiAliasingSpatialKernel } from "../sensor/optical-stack.js";
@@ -83,6 +85,7 @@ import { prepareRgbGamutMapping } from "../color/gamut-mapping.js";
 import { serializeNativeRawDng } from "../capture/native-raw-dng.js";
 import { parseSensorReadoutConversionProfile, resolveSensorReadoutRegime } from "../sensor/raw-readout.js";
 import { resolveChartScene, chartMaterialInputs, CHART_SCENE_PRESETS } from "./chart-scenes.js";
+import { resolveChartMaterialLayers } from "./chart-material-layers.js";
 import { resolveCaptureIlluminant, calculateIlluminantIrradianceScale, buildPlanarSceneRadianceProvider, requireCallerScene, FACADE_SPECTRAL_RANGE_NANOMETERS, resolveChartSizeOption, PHOTOPIC_MAXIMUM_LUMINOUS_EFFICACY_LM_PER_W, planarProviderMaterialOfDirection } from "./scene-radiance.js";
 /** Version of how the facade builds requests. It changes whenever the same input would build a different request. */
 export const SIMULATE_CAPTURE_FACADE_VERSION = "1.0.0";
@@ -93,9 +96,15 @@ export const SIMULATE_CAPTURE_BOX_APERTURE_DEFAULT_SAMPLES = 4;
  * a capture does. `motion.rotation` is a non-zero angular velocity; `sensor.temporalSampleCount` a count above 1.
  */
 export const SIMULATE_CAPTURE_COST_OPTIONS = Object.freeze(["lens.pupilSampling", "lens.projection", "lens.distortion", "lens.vignetting", "lens.psf",
-    "lens.diffraction", "sensor.antiAliasing", "sensor.pixelAperture.box", "sensor.temporalSampleCount", "motion.rotation", "motion.shutter.rolling", "output.borderHandling.mirror", "output.region",
+    "lens.diffraction", "lens.defocus", "sensor.antiAliasing", "sensor.pixelAperture.box", "sensor.temporalSampleCount", "motion.rotation", "motion.shutter.rolling", "output.borderHandling.mirror", "output.region",
     "output.whiteBalance.auto", "output.demosaic.ahd", "output.highlightMode.reconstruct", "output.colorEncoding.wide-gamut", "output.gamutMapping.perceptual",
     "output.format.jpeg", "output.format.png", "output.format.dng"]);
+/**
+ * The options that take the exact-or-fast flag (#395), in the path style of {@link SIMULATE_CAPTURE_COST_OPTIONS}: each accepts
+ * the record form with `fast` and is reported in `diagnostics.fast.applied` when it runs. Every one of them takes the flag,
+ * whether or not it has a fast method yet; one without runs exact and reports `false`.
+ */
+export const SIMULATE_CAPTURE_FAST_OPTIONS = Object.freeze(["lens.diffraction", "sensor.antiAliasing", "sensor.pixelAperture.box", "output.demosaic.ahd"]);
 export const FACADE_EVIDENCE = Object.freeze([Object.freeze({ sourceOrigin: "photivra",
         sourceReference: "photivra:simulate-capture-facade", reuseStatus: "photivra-owned" })]);
 const DEFAULTS = Object.freeze({ camera: "professional", fNumber: 8, shutterSeconds: 1 / 125, iso: 100, compensationStops: 0,
@@ -145,8 +154,52 @@ const AA_MAXIMUM_OFFSET_SITES = 4;
 /** Channel responses kept across calls (`axisChannelResponse`): one entry per distinct sensor, exposure and optics state. */
 const CHANNEL_RESPONSE_CACHE_SIZE = 8;
 const channelResponseCache = new Map();
+/**
+ * #449: diffraction profiles kept across calls, by the JSON of their `createDiffractionLimitedPsfProfile` input (the last
+ * DIFFRACTION_PROFILE_CACHE_SIZE, most recently used last). Every region part and detail tile of one request builds the same
+ * input. The kept record is private: each call gets its own copy, as mutable as a newly built one, so a caller's change
+ * never reaches another call. The copy is made of plain records and arrays (plainDataCopy): the kernel set-up structured-clones
+ * the profile once per spectral node, and in a CPU profile of the 96 × 64 Quality tile that clone took about twice as long
+ * (24 instead of 12 ms per call) on a deep-frozen record or on a structuredClone copy as on a newly built record or this copy.
+ */
+const DIFFRACTION_PROFILE_CACHE_SIZE = 8;
+const diffractionProfileCache = new Map();
+/** A copy of plain data (records, arrays, primitives; typed arrays are sliced), built from ordinary literals. */
+function plainDataCopy(value) {
+    if (Array.isArray(value))
+        return value.map(plainDataCopy);
+    if (ArrayBuffer.isView(value))
+        return value.slice();
+    if (value === null || typeof value !== "object")
+        return value;
+    const copy = {};
+    for (const key of Object.keys(value))
+        copy[key] = plainDataCopy(value[key]);
+    return copy;
+}
+/** The profile of `input` (a pure function of the input record): a copy of the kept one when the same input was built before. */
+function cachedDiffractionProfile(input) {
+    const key = JSON.stringify(input);
+    let kept = diffractionProfileCache.get(key);
+    if (kept)
+        diffractionProfileCache.delete(key);
+    else
+        kept = createDiffractionLimitedPsfProfile(input).value;
+    diffractionProfileCache.set(key, kept);
+    if (diffractionProfileCache.size > DIFFRACTION_PROFILE_CACHE_SIZE)
+        diffractionProfileCache.delete(diffractionProfileCache.keys().next().value);
+    // The same fields in the same order as the built record, frozen at the top level like it; `model` is the frozen constant.
+    return Object.freeze({ ...kept, profile: plainDataCopy(kept.profile), wavelengths: plainDataCopy(kept.wavelengths), quadrature: plainDataCopy(kept.quadrature) });
+}
 /** Default birefringent separation in sites: the two-spot MTF |cos(π·f·d)| then has its first zero at Nyquist, f = 1/(2·pitch). */
 const AA_DEFAULT_SEPARATION_SITES = 1;
+/** #395: the `fast` override of an option record (undefined when absent), which must be a Boolean. */
+function fastOverride(record, path) {
+    const value = record.fast;
+    if (value !== undefined && typeof value !== "boolean")
+        fail(path + ".fast must be true or false.");
+    return value;
+}
 /** Parses `sensor.antiAliasing` into engine point-splitting components (offsets in µm, +x right, +y down). */
 function parseAntiAliasing(value, pitch) {
     requireInputObject(value, "sensor.antiAliasing");
@@ -160,18 +213,18 @@ function parseAntiAliasing(value, pitch) {
         return d;
     };
     if (kind === "four-spot") {
-        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "separationSites"]), d = separation(record), h = d * pitch / 2;
+        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "separationSites", "fast"]), d = separation(record), h = d * pitch / 2;
         return { kind, separationSites: d, components: [[-h, -h], [h, -h], [-h, h], [h, h]].map(([x, y]) => ({ offsetMicrometers: { x: x, y: y }, normalizedWeight: 0.25 })) };
     }
     if (kind === "two-spot") {
-        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "axis", "separationSites"]), d = separation(record), h = d * pitch / 2;
+        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "axis", "separationSites", "fast"]), d = separation(record), h = d * pitch / 2;
         if (record.axis !== "horizontal" && record.axis !== "vertical")
             fail("sensor.antiAliasing.axis must be horizontal or vertical.");
         const axis = record.axis;
         return { kind, axis, separationSites: d, components: [-h, h].map((o) => ({ offsetMicrometers: axis === "horizontal" ? { x: o, y: 0 } : { x: 0, y: o }, normalizedWeight: 0.5 })) };
     }
     if (kind === "point-splitting") {
-        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "components"]);
+        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "components", "fast"]);
         if (!Array.isArray(record.components) || record.components.length === 0 || record.components.length > AA_MAXIMUM_COMPONENTS) {
             fail("sensor.antiAliasing.components must be an array of 1 to " + AA_MAXIMUM_COMPONENTS + " components.");
         }
@@ -283,11 +336,25 @@ function spectrumDigestForm(raw, prepared) {
         values.push(prepared.evaluate(nm));
     return { kind: "function-sampled-1nm", rangeNanometers: [FACADE_SPECTRAL_RANGE_NANOMETERS.minimum, FACADE_SPECTRAL_RANGE_NANOMETERS.maximum], values };
 }
+/**
+ * #449: the CIE 1931 ȳ values at luminanceOf's 5 nm nodes, evaluated once (estimateCie1931ColorMatchingFunctions is a pure
+ * function of the wavelength, so each entry is the value the loop would compute).
+ */
+let luminanceCmfY;
+function luminanceNodesY() {
+    if (luminanceCmfY)
+        return luminanceCmfY;
+    const values = [];
+    for (let nm = FACADE_SPECTRAL_RANGE_NANOMETERS.minimum; nm <= FACADE_SPECTRAL_RANGE_NANOMETERS.maximum; nm += 5)
+        values.push(estimateCie1931ColorMatchingFunctions(nm).y);
+    return (luminanceCmfY = Float64Array.from(values));
+}
 function luminanceOf(radiance) {
+    const cmfY = luminanceNodesY();
     let sum = 0;
-    for (let nm = FACADE_SPECTRAL_RANGE_NANOMETERS.minimum; nm <= FACADE_SPECTRAL_RANGE_NANOMETERS.maximum; nm += 5) {
+    for (let nm = FACADE_SPECTRAL_RANGE_NANOMETERS.minimum, i = 0; nm <= FACADE_SPECTRAL_RANGE_NANOMETERS.maximum; nm += 5, i++) {
         const w = nm === FACADE_SPECTRAL_RANGE_NANOMETERS.minimum || nm === FACADE_SPECTRAL_RANGE_NANOMETERS.maximum ? 2.5 : 5;
-        sum += w * radiance(nm) * estimateCie1931ColorMatchingFunctions(nm).y;
+        sum += w * radiance(nm) * cmfY[i];
     }
     return PHOTOPIC_MAXIMUM_LUMINOUS_EFFICACY_LM_PER_W * sum;
 }
@@ -600,6 +667,53 @@ export function parseDisplayViewOption(value, frameWidth, frameHeight) {
     }
     return { width, height, samplesPerAxis, bitDepth: format === "srgb-8" ? 8 : 16, format: format, ...(region ? { region } : {}) };
 }
+/**
+ * `lens.defocus` (#492): resolves the geometric defocus disc at the resolved f-number on the site pitch and records it.
+ * In focus (c = 0) no kernel exists and nothing else changes (undefined). The capture (step 2a) applies the disc as an
+ * object-space convolution and the display view (step 2b) as a site kernel in its expected-signal tables, and both get it
+ * back; the ideal reference, which has no camera effects, only records it.
+ */
+function resolveDefocusOption(input) {
+    const { run, assume, focalLengthMm, fNumber, focusDistanceM, subjectDistanceM, pitch } = input;
+    const disc = resolveDefocusDisc({ focalLengthMm, aperture: fNumber, focusDistanceM, subjectDistanceM, pitchMicrometers: pitch });
+    const size = disc.diameterMicrometers + " µm (" + disc.diameterSites + " sites of " + pitch + " µm)";
+    let radius;
+    try {
+        radius = requireDefocusDiscKernelRadius(disc.diameterSites);
+    }
+    catch (error) {
+        fail("lens.defocus: the blur circle is " + size + ". " + error.message);
+    }
+    const value = { model: "geometric-disc", scientificStatus: "approximation", diameterMicrometers: disc.diameterMicrometers, diameterSites: disc.diameterSites,
+        kernelRadiusSites: disc.diameterSites === 0 ? null : radius, fNumber, focusDistanceM, subjectDistanceM, samplePitchMicrometers: pitch,
+        defocusCircleModel: { id: "thin-lens-defocus-circle", version: "1.1.0" } };
+    const model = "Geometric defocus of the flat scene plane (an approximation): the thin-lens blur circle of an ideal uniform circular pupil, " +
+        "c = f²·|s − d| / (N·d·(s − f)) (calculateDefocusCircle 1.1.0), as a uniform disc sampled on the site lattice (exact disc area in each site's cell). " +
+        "No diffraction of the defocused wave, aberrations or pupil vignetting. ";
+    if (disc.diameterSites === 0) {
+        assume("lens.defocus", "model", value, model + "In focus (lens.focusDistanceM equals subjectDistanceM): the disc has zero diameter, so no defocus kernel is applied.");
+        return undefined;
+    }
+    if (run === "ideal-reference") {
+        assume("lens.defocus", "model", value, model + "Resolved but not applied: the ideal reference has no camera effects.");
+        return undefined;
+    }
+    // The display view (#492, step 2b): a site kernel in its expected-signal tables (simulate-display-view.ts).
+    if (run === "display-view") {
+        assume("lens.defocus", "model", { ...value, execution: "expected-signal-site-kernel", combinedWithDiffraction: input.diffraction }, model +
+            "Applied in the display view's expected-signal tables as a site kernel on the lattice" + (input.diffraction ? " (with lens.diffraction, each spectral node's " +
+            "diffraction kernel convolved with the disc, a further approximation)" : "") + "; see the view.defocus assumption.");
+        return disc;
+    }
+    // The capture (#492, step 2a): an object-space convolution of the scene radiance on the site lattice.
+    assume("lens.defocus", "model", { ...value, execution: "object-space-convolution", combinedWithDiffraction: input.diffraction }, model +
+        "Applied as an object-space convolution: the scene radiance on the site lattice is convolved with the disc, the same kernel at every spectral node, " +
+        "and each site query is answered with the result (for a flat scene and a still, distortion-free rectilinear camera every disc point a site sees is the scene point of another site). " +
+        (input.diffraction ? "With lens.diffraction, each spectral node's diffraction kernel is convolved with the disc and applied as one kernel. That is a further approximation: " +
+            "the defocused wave PSF of a circular pupil is not exactly the in-focus Airy pattern convolved with the geometric disc. " : "") +
+        "The disc kernel is a sampling of the disc on the site lattice; lens.pupilSampling (ray-sampled, no diffraction) is the independent reference.");
+    return disc;
+}
 /** Internal: passed as the view of a "display-view" run to resolve the request without a view (`prepareDisplayView`, #387). */
 export const DISPLAY_VIEW_WITHOUT_VIEW = Symbol("display view without view");
 /**
@@ -610,7 +724,7 @@ export async function runCapture(options, run, viewOption, renderView) {
     const started = Date.now(), idealReference = run === "ideal-reference", displayView = run === "display-view";
     requireInputObject(options, "simulateCapture options");
     const top = allowKeys(options, "simulateCapture options", ["camera", "lens", "exposure", "scene", "subjectDistanceM", "chartSize", "illuminant",
-        "illuminanceLux", "output", "sensor", "motion", "signal", "onProgress"]);
+        "illuminanceLux", "output", "sensor", "motion", "fast", "signal", "onProgress"]);
     const signal = top.signal, onProgress = top.onProgress;
     if (signal !== undefined && (typeof signal !== "object" || signal === null || typeof signal.aborted !== "boolean"))
         fail("signal must be an AbortSignal.");
@@ -636,7 +750,7 @@ export async function runCapture(options, run, viewOption, renderView) {
         preset = parseCallerCameraPreset(cameraOption);
     const body = preset.body, lens = preset.lens;
     // Lens
-    const lensOptions = allowKeys(top.lens, "lens", ["focalLengthMm", "fNumber", "focusDistanceM", "pupilSampling", "projection", "distortion", "vignetting", "psf", "diffraction", "prime"]);
+    const lensOptions = allowKeys(top.lens, "lens", ["focalLengthMm", "fNumber", "focusDistanceM", "pupilSampling", "projection", "distortion", "vignetting", "psf", "diffraction", "prime", "defocus"]);
     // Generic prime (2.3): resolved on the simulated frame's size, which the output and sensor sections validate again below.
     let prime;
     if (lensOptions.prime !== undefined) {
@@ -669,7 +783,9 @@ export async function runCapture(options, run, viewOption, renderView) {
         fail("The " + prime.lensId + " focuses no closer than " + prime.minimumFocusDistanceM + " m (max(0.10 m, f·(1 + 1/0.15))); subjectDistanceM and lens.focusDistanceM must be at least that.");
     let pupil;
     if (lensOptions.pupilSampling === undefined)
-        assume("lens.pupilSampling", "default", null, "No pupil sampling: each scene query follows the central (chief) ray, so defocus and depth of field are not rendered. Enable lens.pupilSampling for an ideal circular pupil.");
+        assume("lens.pupilSampling", "default", null, lensOptions.defocus === undefined ?
+            "No pupil sampling: each scene query follows the central (chief) ray, so defocus and depth of field are not rendered. Enable lens.pupilSampling for an ideal circular pupil." :
+            "No pupil sampling: each scene query follows the central (chief) ray; defocus of the scene plane is the lens.defocus option's (see the lens.defocus assumption).");
     else {
         const p = allowKeys(lensOptions.pupilSampling, "lens.pupilSampling", ["radialSamples", "angularSamples"]);
         // The environment pupil contract admits 4..64 azimuthal midpoints and at most 256 rays.
@@ -714,22 +830,39 @@ export async function runCapture(options, run, viewOption, renderView) {
         lensPsf = p;
     }
     // Diffraction (2.1): validated here, built once the f-number is resolved.
-    let diffractionRadiusOption;
+    let diffractionRadiusOption, diffractionFast;
     if (lensOptions.diffraction !== undefined) {
         const d = lensOptions.diffraction;
         if (d === "circular-aperture")
             diffractionRadiusOption = null;
         else {
-            const record = allowKeys(d, "lens.diffraction", ["aperture", "kernelRadiusSamples"]);
-            if (record.aperture !== "circular-aperture")
-                fail("lens.diffraction must be \"circular-aperture\" or { aperture: \"circular-aperture\", kernelRadiusSamples }.");
+            const record = allowKeys(d, "lens.diffraction", ["kind", "aperture", "kernelRadiusSamples", "fast"]);
+            // #395: the record names the model by `kind`; `aperture` is its deprecated alias (until 3.0.0).
+            if (record.kind !== undefined && record.aperture !== undefined)
+                fail("lens.diffraction takes kind or its deprecated alias aperture, not both.");
+            const model = record.kind !== undefined ? record.kind : record.aperture;
+            if (model !== "circular-aperture")
+                fail("lens.diffraction must be \"circular-aperture\" or { kind: \"circular-aperture\", kernelRadiusSamples, fast }.");
             diffractionRadiusOption = record.kernelRadiusSamples === undefined ? null : integerIn(record.kernelRadiusSamples, "lens.diffraction.kernelRadiusSamples", 0, 32);
+            diffractionFast = fastOverride(record, "lens.diffraction");
         }
         if (lensPsf)
             fail("lens.diffraction cannot be combined with lens.psf: diffraction would be counted twice.");
         if (pupil)
             fail("lens.diffraction cannot be combined with lens.pupilSampling: the environment contract does not mix a sampled PSF with pupil rays.");
     }
+    // Defocus (#492): validated here, resolved once the f-number is.
+    let defocusModel;
+    if (lensOptions.defocus !== undefined) {
+        const record = allowKeys(lensOptions.defocus, "lens.defocus", ["model"]);
+        if (record.model !== "geometric-disc")
+            fail("lens.defocus.model must be \"geometric-disc\".");
+        if (pupil)
+            fail("lens.defocus cannot be combined with lens.pupilSampling: the pupil rays already render defocus, so it would be counted twice.");
+        if (lensPsf)
+            fail("lens.defocus cannot be combined with lens.psf: a caller PSF declares its own defocus, so it could be counted twice.");
+        defocusModel = "geometric-disc";
+    }
     // Motion (2.0): constant camera rotation and the shutter type.
     const motionOptions = allowKeys(top.motion, "motion", ["angularVelocityRadPerSec", "shutter", "rollingShutterSkewSeconds"]);
     const angular = { pitch: 0, yaw: 0, roll: 0 };
@@ -824,16 +957,18 @@ export async function runCapture(options, run, viewOption, renderView) {
         pick(sensorOptions, "temporalSampleCount", "sensor.temporalSampleCount", DEFAULTS.temporalSampleCount, "One temporal sample: the static scene and still camera make more samples unnecessary."), "sensor.temporalSampleCount", 1, 256);
     const noiseSeed = integerIn(pick(sensorOptions, "noiseSeed", "sensor.noiseSeed", DEFAULTS.noiseSeed, "Fixed noise seed 1 (deterministic output)."), "sensor.noiseSeed", 0, 0xffffffff);
     const antiAliasing = sensorOptions.antiAliasing === undefined ? undefined : parseAntiAliasing(sensorOptions.antiAliasing, pitch);
+    const antiAliasingFast = antiAliasing ? fastOverride(sensorOptions.antiAliasing, "sensor.antiAliasing") : undefined;
     // Pixel aperture (2.3): N × N midpoint nodes over the square photosite; 1 = the default centre sample.
-    let boxSamples = 1;
+    let boxSamples = 1, boxFast;
     if (sensorOptions.pixelAperture !== undefined && sensorOptions.pixelAperture !== "point") {
         const a = sensorOptions.pixelAperture;
         if (a === "box")
             boxSamples = SIMULATE_CAPTURE_BOX_APERTURE_DEFAULT_SAMPLES;
         else {
-            const record = allowKeys(a, "sensor.pixelAperture", ["kind", "samplesPerAxis"]);
+            const record = allowKeys(a, "sensor.pixelAperture", ["kind", "samplesPerAxis", "fast"]);
             if (record.kind !== "box")
-                fail("sensor.pixelAperture must be \"point\", \"box\" or { kind: \"box\", samplesPerAxis }.");
+                fail("sensor.pixelAperture must be \"point\", \"box\" or { kind: \"box\", samplesPerAxis, fast }.");
+            boxFast = fastOverride(record, "sensor.pixelAperture");
             boxSamples = record.samplesPerAxis === undefined ? SIMULATE_CAPTURE_BOX_APERTURE_DEFAULT_SAMPLES : integerIn(record.samplesPerAxis, "sensor.pixelAperture.samplesPerAxis", 1, 16);
         }
     }
@@ -843,7 +978,7 @@ export async function runCapture(options, run, viewOption, renderView) {
     if (displayView) {
         const unsupported = (option, reason) => fail("simulateDisplayView does not support " + option + ": " + reason);
         if (pupil)
-            unsupported("lens.pupilSampling", "defocus moves each query off the site lattice the expected-signal tables use.");
+            unsupported("lens.pupilSampling", "pupil rays move each query off the site lattice the expected-signal tables use; lens.defocus renders the defocus of the scene plane on the lattice.");
         if (lensFieldMapping)
             unsupported("lens.projection or lens.distortion", "the expected signal assumes the ideal rectilinear, distortion-free mapping of the site lattice.");
         if (vignetting)
@@ -865,10 +1000,35 @@ export async function runCapture(options, run, viewOption, renderView) {
         layout: { kind: "periodic-mosaic", repeatWidthSites: 2, repeatHeightSites: 2, siteChannelIds: ["red", "green", "green", "blue"], anchor: "native-sensor-top-left-site" } };
     // Demosaic (2.0): built-in Bayer kernels and border handling. Omitted, the 1.0 bilinear kernels and a
     // one-site rendered border are used unchanged.
-    const demosaicOption = outputOptions.demosaic, borderOption = outputOptions.borderHandling;
+    // #395: the record form { kind, fast } names the same demosaic.
+    let demosaicOption, demosaicFast;
+    if (outputOptions.demosaic !== undefined && typeof outputOptions.demosaic === "object" && outputOptions.demosaic !== null) {
+        const record = allowKeys(outputOptions.demosaic, "output.demosaic", ["kind", "fast"]);
+        if (record.kind !== "bilinear" && record.kind !== "ahd")
+            fail("output.demosaic must be bilinear or ahd, or { kind, fast }.");
+        demosaicOption = record.kind;
+        demosaicFast = fastOverride(record, "output.demosaic");
+    }
+    else
+        demosaicOption = outputOptions.demosaic;
+    const borderOption = outputOptions.borderHandling;
     if (demosaicOption !== undefined && demosaicOption !== "bilinear" && demosaicOption !== "ahd")
         fail("output.demosaic must be bilinear or ahd.");
     const ahd = demosaicOption === "ahd";
+    // #395: exact or fast per option. No option has a fast method yet, so each runs exact and reports false.
+    if (top.fast !== undefined && typeof top.fast !== "boolean")
+        fail("fast must be true or false.");
+    const fastTop = top.fast === true;
+    const fastInUse = [["lens.diffraction", diffractionRadiusOption !== undefined, diffractionFast],
+        ["sensor.antiAliasing", antiAliasing !== undefined, antiAliasingFast], ["sensor.pixelAperture.box", boxAperture, boxFast], ["output.demosaic.ahd", ahd, demosaicFast]];
+    const fastApplied = {};
+    for (const [option, used] of fastInUse)
+        if (used)
+            fastApplied[option] = false;
+    const fastReport = Object.freeze({
+        requested: fastTop || [diffractionFast, antiAliasingFast, boxFast, demosaicFast].some((value) => value === true),
+        applied: Object.freeze(fastApplied), assurance: "engine-reference"
+    });
     if (borderOption !== undefined && borderOption !== "margin" && borderOption !== "mirror")
         fail("output.borderHandling must be margin or mirror.");
     const builtInDemosaic = demosaicOption === undefined ? undefined : createBuiltInBayerDemosaicProfiles({ kernel: "bilinear",
@@ -969,10 +1129,14 @@ export async function runCapture(options, run, viewOption, renderView) {
     const illuminant = resolveCaptureIlluminant(illuminantOption);
     const illuminanceLux = positive(pick(top, "illuminanceLux", "illuminanceLux", SIMULATE_CAPTURE_DEFAULT_ILLUMINANCE_LUX, "π·10·N²/(0.65·t·S·0.18) lux at f/8, 1/125 s, ISO 100 (CIPA DC-004 standard output sensitivity H = 10/S and camera equation H = 0.65·L·t/N²): an 18 % grey card then gets the reference exposure for the default settings. It does not follow the caller's exposure settings."), "illuminanceLux");
     const irradianceScale = calculateIlluminantIrradianceScale(illuminant.shape, illuminanceLux);
-    let chart, callerScene;
+    let chart, callerScene, materialLayers;
     const sceneRecord = sceneOption;
     if ("kind" in sceneRecord) {
-        callerScene = requireCallerScene(sceneOption);
+        // #491: a declared material-layers scene is its callerScene (the same validation, materials, digest and bytes as passing that scene);
+        // the resolved layers are kept for the display view's GPU renderer.
+        if (sceneRecord.kind === "material-layers")
+            materialLayers = resolveChartMaterialLayers({ scene: sceneOption, aspect: chartSize ? chartSize.heightM / chartSize.widthM : aspect });
+        callerScene = requireCallerScene(materialLayers ? materialLayers.callerScene : sceneOption);
     }
     else {
         chart = resolveChartScene({ scene: sceneOption, aspect: chartSize ? chartSize.heightM / chartSize.widthM : aspect });
@@ -1095,6 +1259,19 @@ export async function runCapture(options, run, viewOption, renderView) {
     fNumber = resolution.resolvedSettings.aperture ?? fNumber;
     shutterSeconds = resolution.resolvedSettings.shutterSeconds ?? shutterSeconds;
     const resolvedIso = resolution.resolvedSettings.iso ?? iso;
+    const defocusDisc = defocusModel === undefined ? undefined :
+        resolveDefocusOption({ run, assume, focalLengthMm, fNumber, focusDistanceM, subjectDistanceM, pitch, diffraction: diffractionRadiusOption !== undefined });
+    // #492: the capture applies the disc as an object-space convolution, which needs every disc point a site sees to be another site's scene point.
+    if (defocusDisc) {
+        const reason = rotating ? "camera rotation (motion.angularVelocityRadPerSec)" : lensFieldMapping ? "lens.projection or lens.distortion" : vignetting ? "lens.vignetting" : undefined;
+        if (reason !== undefined)
+            fail("simulateCapture does not support lens.defocus out of focus with " + reason + ": the defocus disc is applied as an object-space convolution " +
+                "on the site lattice, and " + reason + " moves the scene points the sites see off that lattice. Set lens.focusDistanceM equal to subjectDistanceM, or omit one of the two options.");
+    }
+    // #492: the disc on the site lattice (radius 0 for a disc inside one cell: the identity, still applied).
+    const defocusKernel = defocusDisc && !displayView ? createDefocusDiscSiteKernel(defocusDisc.diameterSites) ?? undefined : undefined;
+    // The display view's disc (#492, step 2b): its expected-signal tables apply it (simulate-display-view.ts).
+    const displayViewDefocus = displayView ? defocusDisc : undefined;
     // Sensor readout for the ISO setting. Standard output sensitivity S = 10/H (CIPA DC-004 §3.2) is defined at the
     // output, independent of pixel size, while the collected charge is proportional to the sensitive-aperture area
     // (EMVA 1288 Release 4.0, Eq. 3). The tier's signal chain is anchored to the 6 µm aperture; at another area the
@@ -1310,7 +1487,8 @@ export async function runCapture(options, run, viewOption, renderView) {
             uncertainty: { kind: "not-quantified", limitation: "Analytic planar scene." },
             fidelity: { spectral: "wavelength-resolved", material: "spectral-data", visibility: "resolved", directTransport: "approximation", indirectTransport: "not-modeled" },
             wavelengthChangingTransportModeled: false, volumetricTransportModeled: false, polarizationModeled: false, evidence, limitations: ["Engine-authored planar chart or caller scene function.",
-                ...(diffractionObjectSpace ? ["Radiance is the scene radiance convolved with the lens diffraction PSF mapped onto the scene plane (object-space convolution, request.diffraction)."] : [])] }
+                ...(diffractionObjectSpace ? ["Radiance is the scene radiance convolved with the lens diffraction PSF mapped onto the scene plane (object-space convolution, request.diffraction)."] : []),
+                ...(defocusKernel ? ["Radiance is the scene radiance convolved with the geometric defocus disc mapped onto the scene plane (object-space convolution, lens.defocus)."] : [])] }
     };
     const lensId = lensExposure.profileId;
     const opticsProfile = { schemaVersion: "0.1.0", profileId: lensId + ":facade-transmission", profileVersion: SIMULATE_CAPTURE_FACADE_VERSION, lensProfileId: lensId,
@@ -1333,9 +1511,11 @@ export async function runCapture(options, run, viewOption, renderView) {
             maximumSubintervalWidthNanometers: spectralStep }]));
     // Diffraction (2.1): Airy kernels at the resolved f-number on the site pitch, one per spectral node of the sensor quadrature.
     let diffraction, diffractionPsf;
+    // The spectral nodes of the sensor quadrature, over all channels, ascending.
+    const quadratureWavelengths = () => [...new Set(CHANNELS.flatMap((channelId) => calculateSensorSpectralQuadrature({ ...spectralSamplingByChannel[channelId], colorSamplingProfile,
+            spectralResponseProfile: spectralResponseProfiles[channelId] }).value.nodes.map((node) => node.wavelengthNanometers)))].sort((a, b) => a - b);
     if (diffractionRadiusOption !== undefined) {
-        const wavelengths = [...new Set(CHANNELS.flatMap((channelId) => calculateSensorSpectralQuadrature({ ...spectralSamplingByChannel[channelId], colorSamplingProfile,
-                spectralResponseProfile: spectralResponseProfiles[channelId] }).value.nodes.map((node) => node.wavelengthNanometers)))].sort((a, b) => a - b);
+        const wavelengths = quadratureWavelengths();
         const lambdaN = wavelengths[wavelengths.length - 1] / 1000 * fNumber * imageDistanceMm / focalLengthMm;
         // The environment resolves the PSF at each pre-filter source point, up to the largest split offset outside the imaging area.
         const aaReachMm = antiAliasing ? Math.max(...antiAliasing.components.map((c) => Math.max(Math.abs(c.offsetMicrometers.x), Math.abs(c.offsetMicrometers.y)))) / 1000 : 0;
@@ -1343,13 +1523,18 @@ export async function runCapture(options, run, viewOption, renderView) {
         // larger tail energy outside it is listed per wavelength like any other (2.2.1 states the cap in the explanation).
         const thirdRingSites = Math.max(1, Math.ceil(AIRY_THIRD_ZERO_PER_LAMBDA_N * lambdaN / pitch));
         const kernelRadiusSamples = diffractionRadiusOption ?? Math.min(32, thirdRingSites);
-        diffraction = createDiffractionLimitedPsfProfile({ aperture: "circular", focalLengthMm, apertureFNumber: fNumber, focus: { kind: "finite", distanceM: focusDistanceM },
+        const profileInput = { aperture: "circular", focalLengthMm, apertureFNumber: fNumber, focus: { kind: "finite", distanceM: focusDistanceM },
             wavelengthsNm: wavelengths, samplePitchMicrometers: pitch, kernelRadiusSamples, fieldHalfExtentMm: aaReachMm === 0 ? { x: imagingArea.widthMm / 2, y: imagingArea.heightMm / 2 } :
                 { x: imagingArea.widthMm / 2 + aaReachMm, y: imagingArea.heightMm / 2 + aaReachMm },
-            profileId: "facade-diffraction-airy" }).value;
+            profileId: "facade-diffraction-airy" };
+        // #449: a copy of the profile kept for this input; it equals createDiffractionLimitedPsfProfile(profileInput).value field by
+        // field, so the registration below (keyed by profileInput) holds for it.
+        diffraction = cachedDiffractionProfile(profileInput);
         diffractionPsf = { kind: "sampled-local", configuration: { psf: { profile: diffraction.profile, focalLengthMm, focus: { kind: "finite", distanceM: focusDistanceM },
                     apertureFNumber: fNumber, signedDefocusImagePlaneMicrometers: 0 }, psfWavelengthBasis: { value: "vacuum", evidence },
                 spatialModel: { kind: "destination-local-shift-invariant-approximation", evidence, limitation: "Diffraction-limited Airy PSF, the same at every field point." } } };
+        // Requests with the same profile input and PSF fields share their site diffraction kernels (optics/site-diffraction-kernel.ts).
+        registerDiffractionPsfKey(diffractionPsf.configuration.psf, profileInput);
         assume("lens.diffraction", "model", { model: diffraction.model, aperture: "circular-aperture", fNumber, workingFNumber: diffraction.workingFNumber,
             kernelRadiusSamples, samplePitchMicrometers: pitch, maximumTruncatedEnergyFraction: diffraction.maximumTruncatedEnergyFraction,
             truncatedEnergyByWavelength: diffraction.wavelengths.map((w) => ({ wavelengthNm: w.wavelengthNm, truncatedEnergyFraction: w.truncatedEnergyFraction })),
@@ -1361,9 +1546,36 @@ export async function runCapture(options, run, viewOption, renderView) {
                 "Applied through the environment PSF quadrature (one scene query per kernel tap), because camera rotation, a lens field mapping or vignetting moves the taps off the site lattice. ") +
             "No defocus, aberration or pupil clipping; " + (boxAperture ? "the pixel aperture is integrated as declared by sensor.pixelAperture." : "the sensor pixel aperture is still point-sampled at the site centre."));
     }
+    // #492: each spectral node's kernel for lens.defocus out of focus: the disc, or with lens.diffraction (always on the object-space path here)
+    // the node's diffraction kernel convolved with the disc, radius R_diffraction + R_defocus (built on first use, kept for the request).
+    let defocusSiteKernels;
+    if (defocusKernel) {
+        if (diffraction) {
+            const diffractionRadius = diffraction.kernelRadiusSamples, combined = new Map(), profileWavelengths = diffraction.profile.axes.wavelengthNm;
+            const radius = diffractionRadius + defocusKernel.radius;
+            // At most 32 + 64 = 96 sites (the two caps). Neither the expected-signal table nor the provider's own gather (diffraction-provider.ts)
+            // uses the public 32-site limit of calculateIrradianceConvolution; the combination costs at most about 0.1 s per spectral node
+            // (measured, docs/QUICK_START.md "Optics"), so no tighter limit applies.
+            const psfConfiguration = diffractionPsf.configuration.psf;
+            defocusSiteKernels = { radius, wavelengthsNm: profileWavelengths, at(wavelengthNm) {
+                    let kernel = combined.get(wavelengthNm);
+                    if (!kernel) {
+                        if (!profileWavelengths.includes(wavelengthNm))
+                            fail("simulateCapture: a spectral node has no diffraction kernel.");
+                        kernel = convolveSiteKernels(siteDiffractionKernel(psfConfiguration, wavelengthNm, pitch, diffractionRadius, "simulateCapture: diffraction kernels must sample the site pitch exactly."), diffractionRadius, defocusKernel.weights, defocusKernel.radius);
+                        combined.set(wavelengthNm, kernel);
+                    }
+                    return kernel;
+                } };
+        }
+        else
+            defocusSiteKernels = { radius: defocusKernel.radius, wavelengthsNm: quadratureWavelengths(), at: () => defocusKernel.weights };
+    }
     const psf = lensPsf ?? (diffractionObjectSpace ? { kind: "not-applied", evidence,
         limitation: "No environment PSF: lens diffraction is applied upstream by the scene provider as an object-space convolution (request.diffraction)." } : undefined) ??
-        diffractionPsf ?? { kind: "not-applied", evidence, limitation: "No lens PSF (point optics)." };
+        diffractionPsf ?? (defocusSiteKernels ? { kind: "not-applied", evidence,
+        limitation: "No environment PSF: lens defocus is applied upstream by the scene provider as an object-space convolution (lens.defocus)." } : undefined) ??
+        { kind: "not-applied", evidence, limitation: "No lens PSF (point optics)." };
     const pupilRecord = pupil ? { kind: "ideal-uniform-circular-pupil", radialSampleCount: pupil.radialSamples, angularSampleCount: pupil.angularSamples, evidence,
         limitation: "Ideal uniform circular pupil; finite ray sampling, no convergence claim." } : undefined;
     const chargeSamplingProfile = { schemaVersion: "0.1.0", profileId: IDS.chargeSampling, completenessProfileId: IDS.completeness, scientificStatus: "approximation",
@@ -1400,14 +1612,19 @@ export async function runCapture(options, run, viewOption, renderView) {
     const readTile = async (request) => ({ ...request, sites: Array.from({ length: request.width }, (_, j) => siteInput(request.y * nativeWidth + request.x + j)) });
     const yieldControl = createHostYield().yieldControl;
     const perSite = queriesPerSite * (diffraction && psf === diffractionPsf ? (2 * diffraction.kernelRadiusSamples + 1) ** 2 : 1);
-    let diffractionMs = 0, demosaicMs, encodeMs;
-    const diffractedProvider = (window) => diffraction && diffractionObjectSpace ? createDiffractedPlanarProvider({ base: provider, psf: diffractionPsf.configuration.psf,
-        wavelengthsNm: diffraction.profile.axes.wavelengthNm, kernelRadius: diffraction.kernelRadiusSamples, nativeWidth, nativeHeight, outputWidth: width,
-        sitePitchMicrometers: pitch, distanceM: subjectDistanceM, metresPerFrameUnit, onConvolution: (ms) => { diffractionMs += ms; },
-        // Region (2.6): convolve only the lattice the region's native sites query; the values are the whole render's.
+    let diffractionMs = 0, defocusMs = 0, demosaicMs, encodeMs;
+    const diffractedProvider = (window) => defocusSiteKernels ? createDiffractedPlanarProvider({ base: provider, siteKernels: defocusSiteKernels.at,
+        wavelengthsNm: defocusSiteKernels.wavelengthsNm, kernelRadius: defocusSiteKernels.radius, nativeWidth, nativeHeight, outputWidth: width,
+        sitePitchMicrometers: pitch, distanceM: subjectDistanceM, metresPerFrameUnit, onConvolution: (ms) => { defocusMs += ms; },
         ...(window ? { window } : {}),
-        // The environment queries each site at each aperture node minus each split offset (sites, +x right, +y down).
-        ...(antiAliasing || boxSamples > 1 ? { queryOffsetsSites: apertureNodeOffsets(boxSamples).flatMap((node) => (antiAliasing ? antiAliasing.components : [{ offsetMicrometers: { x: 0, y: 0 } }]).map((c) => ({ x: node.x - c.offsetMicrometers.x / pitch, y: node.y - c.offsetMicrometers.y / pitch }))) } : {}) }) : provider;
+        ...(antiAliasing || boxSamples > 1 ? { queryOffsetsSites: apertureNodeOffsets(boxSamples).flatMap((node) => (antiAliasing ? antiAliasing.components : [{ offsetMicrometers: { x: 0, y: 0 } }]).map((c) => ({ x: node.x - c.offsetMicrometers.x / pitch, y: node.y - c.offsetMicrometers.y / pitch }))) } : {}) }) :
+        diffraction && diffractionObjectSpace ? createDiffractedPlanarProvider({ base: provider, psf: diffractionPsf.configuration.psf,
+            wavelengthsNm: diffraction.profile.axes.wavelengthNm, kernelRadius: diffraction.kernelRadiusSamples, nativeWidth, nativeHeight, outputWidth: width,
+            sitePitchMicrometers: pitch, distanceM: subjectDistanceM, metresPerFrameUnit, onConvolution: (ms) => { diffractionMs += ms; },
+            // Region (2.6): convolve only the lattice the region's native sites query; the values are the whole render's.
+            ...(window ? { window } : {}),
+            // The environment queries each site at each aperture node minus each split offset (sites, +x right, +y down).
+            ...(antiAliasing || boxSamples > 1 ? { queryOffsetsSites: apertureNodeOffsets(boxSamples).flatMap((node) => (antiAliasing ? antiAliasing.components : [{ offsetMicrometers: { x: 0, y: 0 } }]).map((c) => ({ x: node.x - c.offsetMicrometers.x / pitch, y: node.y - c.offsetMicrometers.y / pitch }))) } : {}) }) : provider;
     // Built on first use: a capture that takes the tabulated path (#394 step 2) never queries it, and its kernels cost a setup.
     let rawProviderBuilt;
     const rawProvider = () => (rawProviderBuilt ??= diffractedProvider(regionNative));
@@ -1441,9 +1658,11 @@ export async function runCapture(options, run, viewOption, renderView) {
             delete environment.evaluateApertureRadiance;
             environments[channel] = environment;
         }
-        // The responses are a function of these records alone (the radiance is replaced per node), and a request split into region
-        // tiles builds the same records for every tile, so they are kept across calls (the last CHANNEL_RESPONSE_CACHE_SIZE).
-        const key = JSON.stringify(CHANNELS.map((c) => environments[c]));
+        // The responses are a function of these records without their scene bindings: the radiance is replaced at every node,
+        // and the bindings (provider, illumination and material profiles) are only checked, never enter a number. So a chart,
+        // illuminant or illuminance change keeps the entry (#443). A request split into region tiles builds the same records for
+        // every tile. The entries are kept across calls (the last CHANNEL_RESPONSE_CACHE_SIZE).
+        const key = JSON.stringify(CHANNELS.map((c) => ({ ...environments[c], sceneBindings: undefined })));
         const copy = (responses) => Object.fromEntries(CHANNELS.map((c) => [c, new Map(responses[c])]));
         const cached = channelResponseCache.get(key);
         let electronsPerRadiance;
@@ -1454,15 +1673,10 @@ export async function runCapture(options, run, viewOption, renderView) {
         }
         else {
             electronsPerRadiance = {};
-            for (const channel of CHANNELS) {
-                // Planned once per channel and executed per spectral node: calculateEnvironmentSensorPhotoSignal is this plan and execution.
-                const photoPlan = planEnvironmentSensorPhotoSignal(environments[channel]);
-                const electrons = (radiance) => executeEnvironmentSensorPhotoSignal(photoPlan, (request) => ({ ...provider.evaluateRadiance(request), spectralRadianceWattsPerSquareMeterSteradianNanometer: radiance(request.wavelengthNanometers) })).value
-                    .photo.value.photoSignal.expectedGeneratedElectronCount;
-                const nodes = new Set();
-                electrons((nm) => { nodes.add(nm); return 1; });
-                electronsPerRadiance[channel] = new Map([...nodes].sort((a, b) => a - b).map((node) => [node, electrons((nm) => (nm === node ? 1 : 0))]));
-            }
+            // One chain execution per channel, each node's electrons read from its own rate term (#443; exact, see channel-response.ts).
+            // The records are built above for this call only, so they are planned as engine-owned data.
+            for (const channel of CHANNELS)
+                electronsPerRadiance[channel] = calculateChannelElectronsPerRadiance(environments[channel], (request) => provider.evaluateRadiance(request), caller);
             // Callers get their own maps; the cached ones are never handed out.
             channelResponseCache.set(key, copy(electronsPerRadiance));
             if (channelResponseCache.size > CHANNEL_RESPONSE_CACHE_SIZE)
@@ -1485,7 +1699,7 @@ export async function runCapture(options, run, viewOption, renderView) {
     // Display view: the renderer that simulate-display-view.ts passes in reads this request's resolved state, so a bundle
     // that only captures does not contain the display view.
     if (displayView)
-        return await renderView({ ahd, antiAliasing, aspect, assume, assumptions, axisChannelResponse, boxSamples, buildProvider, callerScene, chart, chartReport, chartSize, diffraction, diffractionPsf, fNumber, focalLengthMm, focusDistanceM, height, highlightMode, illuminanceLux, illuminant, illuminantOption, imagingArea, intentOf, metresPerFrameUnit, noiseSeed, outputOptions, parsedView, pitch, preset, provider, regimeByChannel, resolvedIso, sceneOption, scenePreset, shutterSeconds, started, subjectDistanceM, toneCurve, whiteBalanceOption, whiteBalanceState, width, checkAbort, margin, mode, nativeHeight, nativeWidth, sourceSha256, yieldControl, kelvinWhiteBalanceInput });
+        return await renderView({ ahd, fastReport, antiAliasing, aspect, assume, assumptions, axisChannelResponse, boxSamples, buildProvider, callerScene, chart, materialLayers, chartReport, chartSize, diffraction, defocus: displayViewDefocus, diffractionPsf, fNumber, focalLengthMm, focusDistanceM, height, highlightMode, illuminanceLux, illuminant, illuminantOption, imagingArea, intentOf, metresPerFrameUnit, noiseSeed, outputOptions, parsedView, pitch, preset, provider, regimeByChannel, resolvedIso, sceneOption, scenePreset, shutterSeconds, started, subjectDistanceM, toneCurve, whiteBalanceOption, whiteBalanceState, width, checkAbort, margin, mode, nativeHeight, nativeWidth, sourceSha256, yieldControl, kelvinWhiteBalanceInput });
     // Ideal reference (2.3): the scene without camera effects, at the capture's own exposure, white balance and encoding.
     if (idealReference) {
         const referenceStarted = clockMs();
@@ -1610,12 +1824,20 @@ export async function runCapture(options, run, viewOption, renderView) {
         const { electronsPerRadiance, wavelengths } = axisChannelResponse("simulateCapture");
         const perNode = CHANNELS.map((c) => Float64Array.from(wavelengths, (nm) => electronsPerRadiance[c].get(nm) ?? 0));
         const sceneMaterials = chart ? chart.materials : callerScene.materials, materialRadiance = provider.materialRadiance;
-        const { signalInput } = buildExpectedSignalInput({ nativeWidth, nativeHeight, width, wavelengths, perNode, apertureNodes: apertureNodeOffsets(boxSamples), boxSamples, antiAliasing, pitch,
-            diffraction: diffraction ? { radius: diffraction.kernelRadiusSamples, psf: diffractionPsf.configuration.psf, profileWavelengths: diffraction.profile.axes.wavelengthNm } : undefined,
+        const { signalInput: builtSignalInput } = buildExpectedSignalInput({ nativeWidth, nativeHeight, width, wavelengths, perNode, apertureNodes: apertureNodeOffsets(boxSamples), boxSamples, antiAliasing, pitch,
+            diffraction: diffraction && !defocusSiteKernels ? { radius: diffraction.kernelRadiusSamples, psf: diffractionPsf.configuration.psf, profileWavelengths: diffraction.profile.axes.wavelengthNm } : undefined,
             materials: { materialAt: provider.chartMaterialAt, whiteRadiance: (nm) => irradianceScale * illuminant.shape.evaluate(nm) / Math.PI,
                 list: [...sceneMaterials.map((m, index) => (m.kind === "neutral" ? { neutral: m.reflectance } : { radiance: (nm) => materialRadiance(index, nm) })),
                     ...(chartSize ? [{ neutral: chartSize.surroundReflectance }] : [])] },
             radianceAt: provider.radianceAt, imagingArea, focalLengthMm, focusDistanceM, subjectDistanceM, metresPerFrameUnit, caller: "simulateCapture" });
+        // #492: with lens.defocus the table convolves the lattice radiance with each node's defocus (or combined) kernel, on the
+        // lattice formula, exactly as the object-space provider does.
+        let signalInput = builtSignalInput;
+        if (defocusSiteKernels) {
+            const lattice = { ...builtSignalInput };
+            delete lattice.queryPoint;
+            signalInput = { ...lattice, kernels: { radius: defocusSiteKernels.radius, perNode: wavelengths.map((nm) => defocusSiteKernels.at(nm)) } };
+        }
         // The verification reads only the region's top-left 2 × 2 block, so its diffraction convolves only that block's lattice; the
         // window never changes a value (see diffraction-provider.ts), so the chain it runs is the whole render's.
         const verificationProvider = diffractedProvider({ x: regionNative?.x ?? 0, y: regionNative?.y ?? 0, width: 2, height: 2 });
@@ -1827,7 +2049,7 @@ export async function runCapture(options, run, viewOption, renderView) {
     }
     const ranOptions = new Set([...(pupil ? ["lens.pupilSampling"] : []), ...(projection !== undefined ? ["lens.projection"] : []),
         ...(distortion ? ["lens.distortion"] : []), ...(vignetting ? ["lens.vignetting"] : []), ...(lensPsf ? ["lens.psf"] : []),
-        ...(diffraction ? ["lens.diffraction"] : []), ...(antiAliasing ? ["sensor.antiAliasing"] : []), ...(boxAperture ? ["sensor.pixelAperture.box"] : []),
+        ...(diffraction ? ["lens.diffraction"] : []), ...(defocusSiteKernels ? ["lens.defocus"] : []), ...(antiAliasing ? ["sensor.antiAliasing"] : []), ...(boxAperture ? ["sensor.pixelAperture.box"] : []),
         ...(temporalSampleCount > 1 ? ["sensor.temporalSampleCount"] : []), ...(rotating ? ["motion.rotation"] : []),
         ...(rollingSchedule ? ["motion.shutter.rolling"] : []), ...(mirrorBorder ? ["output.borderHandling.mirror"] : []), ...(region ? ["output.region"] : []),
         ...(needsAuto ? ["output.whiteBalance.auto"] : []), ...(ahd ? ["output.demosaic.ahd"] : []),
@@ -1847,15 +2069,16 @@ export async function runCapture(options, run, viewOption, renderView) {
             framedWidthM: 2 * metresPerFrameUnit, framedHeightM: 2 * metresPerFrameUnit * aspect, ...(chartReport ? { chart: chartReport } : {}), sourceSha256 },
         diagnostics: { providerEvaluationCount, highlight: developed.highlight, rendering: developed.diagnostics, ...(gamutMappingDiagnostics ? { gamutMapping: gamutMappingDiagnostics } : {}),
             timingsMs: { raw: rawMs, whiteBalance: wbMs, development: devMs, jpeg: jpegMs, total: Date.now() - started,
-                ...(diffraction && diffractionObjectSpace ? { diffraction: diffractionMs } : {}), ...(demosaicMs === undefined ? {} : { demosaic: demosaicMs }),
+                ...(diffraction && diffractionObjectSpace && !defocusSiteKernels ? { diffraction: diffractionMs } : {}), ...(defocusSiteKernels ? { defocus: defocusMs } : {}), ...(demosaicMs === undefined ? {} : { demosaic: demosaicMs }),
                 ...(encodeMs === undefined ? {} : { encode: encodeMs }) },
-            options: Object.freeze(SIMULATE_CAPTURE_COST_OPTIONS.filter((option) => ranOptions.has(option))) },
+            options: Object.freeze(SIMULATE_CAPTURE_COST_OPTIONS.filter((option) => ranOptions.has(option))), fast: fastReport },
         provenance: { scientificStatus: "approximation", cameraPresetId: preset.presetId, cameraPresetVersion: preset.presetVersion,
             evidence: [...FACADE_EVIDENCE, ...preset.evidence],
             composedContracts: ["resolveGenericEquipmentExposureCapabilities", "meterRelativeExposure", "createExposureMeterTargetFromMeteringResult",
                 "resolve" + (mode === "manual" ? "Manual" : mode === "aperture-priority" ? "AperturePriority" : mode === "shutter-priority" ? "ShutterPriority" : "ProgramAuto") + "ExposureMode",
                 ...(rollingSchedule ? ["resolveElectronicRollingShutterExposureSchedule", "createRollingShutterCaptureExposureSchedule"] : []),
-                ...(diffraction ? ["createDiffractionLimitedPsfProfile", ...(diffractionObjectSpace ? ["resolveLensPsfConvolutionKernels", "calculateIrradianceConvolution"] : [])] : []),
+                ...(diffraction ? ["createDiffractionLimitedPsfProfile", ...(diffractionObjectSpace ? ["resolveLensPsfConvolutionKernels", ...(defocusSiteKernels ? [] : ["calculateIrradianceConvolution"])] : [])] : []),
+                ...(defocusSiteKernels ? ["calculateDefocusCircle", "defocus disc site kernel (object-space convolution)"] : []),
                 ...(antiAliasing ? ["resolveAntiAliasingSpatialKernel"] : []), "resolveGenericIsoSignalChain", "createNativeEnvironmentRawTask", ...(needsAuto ? ["estimateAutoWhiteBalance"] : []),
                 ...(builtInDemosaic ? ["createBuiltInBayerDemosaicProfiles"] : []), ...(ahd ? ["createAhdDemosaicTask"] : []),
                 ...(ahd ? ["native RAW development operator (colour, after AHD)", ...(linearPath ? ["resolveRgbColorSpace", ...(perceptual ? ["prepareRgbGamutMapping"] : [])] : ["SDR rendering kernel"])] : linearPath ? ["native RAW development operator (linear, pre-clip)", "resolveRgbColorSpace", ...(perceptual ? ["prepareRgbGamutMapping"] : [])] : ["createNativeRawDevelopmentTask"]),