@photivra/engine 2.9.0 → 2.10.0

package/dist/facade/simulate-capture.js

@@ -72,9 +72,10 @@ 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 } from "../optics/site-diffraction-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";
@@ -96,6 +97,12 @@ export const SIMULATE_CAPTURE_COST_OPTIONS = Object.freeze(["lens.pupilSampling"
     "lens.diffraction", "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 +152,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 +211,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 +334,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;
 }
@@ -610,7 +675,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.");
@@ -714,16 +779,21 @@ 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.");
@@ -824,16 +894,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);
         }
     }
@@ -865,10 +937,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",
@@ -1343,13 +1440,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 })),
@@ -1441,9 +1543,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 +1558,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 +1584,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, 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 });
     // Ideal reference (2.3): the scene without camera effects, at the capture's own exposure, white balance and encoding.
     if (idealReference) {
         const referenceStarted = clockMs();
@@ -1849,7 +1948,7 @@ export async function runCapture(options, run, viewOption, renderView) {
             timingsMs: { raw: rawMs, whiteBalance: wbMs, development: devMs, jpeg: jpegMs, total: Date.now() - started,
                 ...(diffraction && diffractionObjectSpace ? { diffraction: diffractionMs } : {}), ...(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",