@photivra/engine 1.5.0 → 2.1.0

package/dist/capture/native-environment-lean.js

@@ -0,0 +1,974 @@
+// SPDX-License-Identifier: Apache-2.0
+import { InvalidConfigurationError } from "../core/configuration-error.js";
+import { apertureRadianceQuery } from "../sensor/environment-photo-signal.js";
+import { createSensorEqeTemporalPhotoSignal } from "../sensor/temporal-photo-signal.js";
+import { parseSceneRadianceEvaluationResult, validateSceneRadianceEvaluationBindings } from "../schema/scene-radiance.js";
+import { calculateSceneRadianceToSensorIrradiance } from "../optics/scene-to-sensor-irradiance.js";
+import { calculateMappedSensorEnvironmentRadianceQuery, prepareEnvironmentLensFieldMapping } from "../optics/sensor-environment-query.js";
+import { calculateSensorPsfIrradianceQuadrature } from "../optics/sensor-psf-quadrature.js";
+import { sensorPsfSourcePoint } from "../optics/sensor-psf-support.js";
+import { resolveLensSampledPsf, resolveLensSampledPsfKernel } from "../optics/lens-psf-profile.js";
+import { sensorApertureRayValues } from "../optics/sensor-aperture-rays.js";
+import { parseFocusPlane } from "../optics/focus-state.js";
+import { calculateIlluminationVignetting } from "../optics/illumination-vignetting.js";
+import { applyPhysicalCameraRotation, resolveProjectionDistanceMm } from "../motion/camera-rotation.js";
+import { prepareCaptureExposureWindowSampler } from "../sensor/exposure-window.js";
+import { isPublicOpaqueId } from "../core/record-validation.js";
+import { freezeOwnedData } from "../core/owned-data.js";
+import { composeNativeEnvironmentSensorSite } from "./native-environment-optical-stage.js";
+import { calculateNativeRawSite, parseNativeRawProducerSite } from "./sensor-raw-producer.js";
+import { calculateSiteEffectiveSaturationCode } from "./raw-white-level.js";
+import { adcTransfer, resolveSensorReadoutRegime, samplePoisson } from "../sensor/raw-readout.js";
+import { createDeterministicUniformStream, deriveNativeSiteStreamSeedUint32, sampleDeterministicStandardNormal, NATIVE_SITE_CHARGE_STREAM_ID, NATIVE_SITE_READ_NOISE_STREAM_ID } from "../sensor/stochastic-seed.js";
+import { evaluateParsedFixedPatternSite } from "../sensor/fixed-pattern-noise.js";
+/** Most distinct templates kept for one capture event. Any further distinct sites just run the full path. */
+const MAXIMUM_TEMPLATES = 64;
+const SQUARE_MICROMETERS_TO_SQUARE_METERS = 1e-12;
+const REDUCTION_TOLERANCE = 1e-10;
+/** Disables the lean executor process-wide (internal; tests compare both paths). */
+let leanDisabled = false;
+/** Internal counters of lean work (tests assert the lean path actually runs). Not exported from the package. */
+export const nativeEnvironmentLeanStatistics = { plannedSites: 0, executedSites: 0, sensorSites: 0, psfFallbacks: 0 };
+export function setNativeEnvironmentLeanExecutionEnabled(enabled) { leanDisabled = !enabled; }
+function isPlainRecord(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * Strict structural equality of engine-owned structured-clone output: Object.is leaves (0 and -0 differ), plain
+ * records with the same own keys in the same order, dense arrays without extra properties. Anything else is equal
+ * only by reference. `memo` remembers subtrees already proven equal (both sides are engine-owned and unmutated).
+ */
+function sameData(a, b, memo) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+        return false;
+    if (memo.get(a) === b)
+        return true;
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || Object.getPrototypeOf(a) !== Array.prototype || Object.getPrototypeOf(b) !== Array.prototype)
+            return false;
+        const length = a.length;
+        if (length !== b.length)
+            return false;
+        for (let i = 0; i < length; i++)
+            if (!(i in a) || !(i in b) || !sameData(a[i], b[i], memo))
+                return false;
+        if (Object.keys(a).length !== length || Object.keys(b).length !== length)
+            return false;
+    }
+    else {
+        if (Array.isArray(b) || !isPlainRecord(a) || !isPlainRecord(b) || Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
+            return false;
+        if (!sameKeysExcept(a, b, undefined, memo))
+            return false;
+    }
+    memo.set(a, b);
+    return true;
+}
+/** Same own keys in the same order and equal values, except `skip` (compared by the caller). */
+function sameKeysExcept(a, b, skip, memo) {
+    const ak = Object.keys(a), bk = Object.keys(b);
+    if (ak.length !== bk.length || Object.getOwnPropertySymbols(a).length !== 0 || Object.getOwnPropertySymbols(b).length !== 0)
+        return false;
+    for (let i = 0; i < ak.length; i++)
+        if (ak[i] !== bk[i])
+            return false;
+    for (let i = 0; i < ak.length; i++) {
+        const key = ak[i];
+        if (key !== skip && !sameData(a[key], b[key], memo))
+            return false;
+    }
+    return true;
+}
+function plainChild(value, key) {
+    const child = typeof value === "object" && value !== null ? value[key] : undefined;
+    return typeof child === "object" && child !== null && !Array.isArray(child) && isPlainRecord(child) ? child : undefined;
+}
+/** Environment equality except temporalIntegrationId and sensor.spatialSampling.site (index-bound, checked per site). */
+function environmentMatches(e, t, memo) {
+    const er = e, tr = t;
+    if (typeof er !== "object" || er === null || !isPlainRecord(er))
+        return false;
+    const es = plainChild(er, "sensor"), ts = plainChild(tr, "sensor"), ess = plainChild(es, "spatialSampling"), tss = plainChild(ts, "spatialSampling");
+    if (!es || !ts || !ess || !tss)
+        return false;
+    return environmentShallow(er, tr, memo);
+}
+/** Top level and sensor compared key by key so only the two index-bound fields are skipped. */
+function environmentShallow(er, tr, memo) {
+    const ek = Object.keys(er), tk = Object.keys(tr);
+    if (ek.length !== tk.length || Object.getOwnPropertySymbols(er).length !== 0)
+        return false;
+    for (let i = 0; i < ek.length; i++)
+        if (ek[i] !== tk[i])
+            return false;
+    for (const key of ek) {
+        if (key === "temporalIntegrationId")
+            continue;
+        if (key === "sensor") {
+            const es = er.sensor, ts = tr.sensor, sk = Object.keys(es), tsk = Object.keys(ts);
+            if (sk.length !== tsk.length || Object.getOwnPropertySymbols(es).length !== 0)
+                return false;
+            for (let i = 0; i < sk.length; i++)
+                if (sk[i] !== tsk[i])
+                    return false;
+            for (const sensorKey of sk) {
+                if (sensorKey === "spatialSampling") {
+                    if (!sameKeysExcept(es.spatialSampling, ts.spatialSampling, "site", memo))
+                        return false;
+                }
+                else if (!sameData(es[sensorKey], ts[sensorKey], memo))
+                    return false;
+            }
+        }
+        else if (!sameData(er[key], tr[key], memo))
+            return false;
+    }
+    return true;
+}
+export function isLeanEnvironmentPlan(plan) {
+    return typeof plan === "object" && plan !== null && plan.lean === true;
+}
+function siteOf(environment) {
+    const site = plainChild(plainChild(plainChild(environment, "sensor"), "spatialSampling"), "site");
+    return site;
+}
+/** Plans the site-dependent parts with the full planner's arithmetic. Returns undefined on any doubt, and the caller plans in full. */
+function geometry(t, k, frame, environment, index) {
+    try {
+        const x = index % frame.nativeWidth, y = Math.floor(index / frame.nativeWidth), site = siteOf(environment);
+        // Object.is: a -0 coordinate would flow into the full path's outputs, so it takes the full path.
+        if (!site || !Object.is(site.x, x) || !Object.is(site.y, y) || !isPublicOpaqueId(environment.temporalIntegrationId))
+            return undefined;
+        const g = k.geometry;
+        // resolveSensorSamplingAperture: per-site aperture centre and bounds.
+        const siteCenterFromTopLeftX = g.firstX + x * g.pitchX, siteCenterFromTopLeftY = g.firstY + y * g.pitchY;
+        const apertureCenterFromTopLeftX = siteCenterFromTopLeftX + g.offsetX, apertureCenterFromTopLeftY = siteCenterFromTopLeftY + g.offsetY;
+        const imagingWidthMicrometers = g.imagingWidthMm * 1000, imagingHeightMicrometers = g.imagingHeightMm * 1000;
+        if (apertureCenterFromTopLeftX - g.widthUm / 2 < 0 || apertureCenterFromTopLeftY - g.heightUm / 2 < 0 ||
+            apertureCenterFromTopLeftX + g.widthUm / 2 > imagingWidthMicrometers || apertureCenterFromTopLeftY + g.heightUm / 2 > imagingHeightMicrometers)
+            return undefined;
+        const centerX = -g.imagingWidthMm / 2 + apertureCenterFromTopLeftX / 1000, centerY = -g.imagingHeightMm / 2 + apertureCenterFromTopLeftY / 1000;
+        // calculateSensorSpatialSamplingQuadrature: midpoint grid nodes minus the anti-aliasing (AA) offset.
+        const widthMm = g.widthUm / 1000, heightMm = g.heightUm / 1000;
+        const leftMm = centerX - widthMm / 2, topMm = centerY - heightMm / 2;
+        const sources = [];
+        for (const node of k.spatial) {
+            const source = { x: (leftMm + node.xPhase * widthMm) - node.aaX, y: (topMm + node.yPhase * heightMm) - node.aaY };
+            if (!Number.isFinite(source.x) || !Number.isFinite(source.y))
+                return undefined;
+            sources.push(source);
+        }
+        const window = k.sampler({ x: x + .5, y: y + .5 });
+        const start = window.startOffsetSecondsFromOpeningReference, end = window.endOffsetSecondsFromOpeningReference;
+        const duration = window.localExposureDurationSeconds;
+        const e = environment, optics = e.optics, motion = e.motion;
+        const focalLengthMm = optics.focalLengthMm, nominalFNumber = optics.nominalFNumber;
+        const omega = motion.angularVelocityRadPerSec;
+        // The pupil, f-number and focus were validated by the template's full planning (they are site-independent); the ray
+        // arithmetic and its rotation and forward-hemisphere checks run per site through calculateSensorApertureRays' own code.
+        const pupil = e.pupil;
+        if (pupil !== undefined && sensorApertureRayValues({ sourcePointNativeSensorMm: { x: 0, y: 0 }, focalLengthMm, nominalFNumber,
+            angularVelocityRadPerSec: omega, timeSecondsFromOpeningReference: start }, pupil, k.parsedFocus).rays.length !== k.pupilCount)
+            return undefined;
+        // Field throughput at a planned point, as the full planner computes it.
+        const field = e.fieldThroughput;
+        const fieldAt = (point) => {
+            if (field.kind === "unity")
+                return { value: { kind: "unity" }, factor: 1, valid: true };
+            const result = calculateIlluminationVignetting({ imagePointMm: { x: point.x, y: -point.y },
+                profile: field.profile }).value;
+            const imagePoint = { x: point.x, y: -point.y };
+            const scale = Math.max(1, Math.abs(imagePoint.x), Math.abs(imagePoint.y), Math.abs(result.imagePointMm.x), Math.abs(result.imagePointMm.y));
+            const tolerance = Number.EPSILON * 64 * scale, factor = result.linearThroughputFactor;
+            const valid = !(Math.abs(result.imagePointMm.x - imagePoint.x) > tolerance || Math.abs(result.imagePointMm.y - imagePoint.y) > tolerance) &&
+                Number.isFinite(factor) && factor > 0 && factor <= 1;
+            return { value: { kind: "illumination-vignetting-result", result }, factor, valid };
+        };
+        // Tap points per group (spectral-major, spatial-minor). Without a PSF a group has one tap at its destination
+        // (one field throughput per spatial node, shared by its spectral nodes). With a sampled PSF the kernel is resolved
+        // at the destination and the taps sit at sensorPsfSourcePoint offsets, as in the full planner.
+        const S = k.spectralCount, P = k.spatialCount;
+        const tapPoints = [], tapFields = [];
+        const kernels = [];
+        // Without a PSF, the single tap of group gi is the destination sources[gi % P] (no per-group arrays are built).
+        const destinationFields = k.psf === undefined ? sources.map(fieldAt) : undefined;
+        if (k.psf !== undefined)
+            for (let s = 0; s < S; s++)
+                for (let p = 0; p < P; p++) {
+                    const destination = sources[p], gi = s * P + p;
+                    const kernel = resolveLensSampledPsfKernel({ ...k.psf, wavelengthNm: k.wavelengths[s], fieldPointMm: { x: destination.x, y: -destination.y } });
+                    const n = kernel.widthSamples * kernel.heightSamples, weights = kernel.normalizedIntensity;
+                    if (n !== k.tapCounts[gi] || weights.length !== n)
+                        return undefined;
+                    const points = [];
+                    for (let i = 0; i < n; i++) {
+                        const point = sensorPsfSourcePoint(destination, kernel, i % kernel.widthSamples, Math.floor(i / kernel.widthSamples));
+                        // A non-finite kernel weight or tap point would fail the full planner's result checks: plan this site in full.
+                        if (!Number.isFinite(weights[i]) || !Number.isFinite(point.x) || !Number.isFinite(point.y))
+                            return undefined;
+                        points.push(point);
+                    }
+                    tapPoints.push(points);
+                    tapFields.push(points.map(fieldAt));
+                    kernels.push(weights);
+                }
+        const measure = duration / k.temporalCount;
+        let previous = -Infinity;
+        const instants = [];
+        const pd = k.projectionDistanceMm, base = k.requestBase, id = environment.temporalIntegrationId;
+        for (let ti = 0; ti < k.temporalCount; ti++) {
+            const time = start + (ti + .5) * measure;
+            if (!(time > start && time > previous && time < end))
+                return undefined;
+            previous = time;
+            if (!Number.isFinite(time) || time < 0)
+                return undefined;
+            const displacement = { pitch: omega.pitch * time, yaw: omega.yaw * time, roll: omega.roll * time };
+            const taps = [];
+            for (let gi = 0; gi < S * P; gi++) {
+                const s = Math.floor(gi / P), points = destinationFields === undefined ? tapPoints[gi] : undefined;
+                const tapCount = points === undefined ? 1 : points.length;
+                for (let pi = 0; pi < tapCount; pi++) {
+                    const point = points === undefined ? sources[gi % P] : points[pi], sampleId = `${id}-t${ti}-n${gi}-p${pi}`;
+                    const apertureRays = pupil === undefined ? undefined : sensorApertureRayValues({ sourcePointNativeSensorMm: point, focalLengthMm,
+                        nominalFNumber, angularVelocityRadPerSec: omega, timeSecondsFromOpeningReference: time }, pupil, k.parsedFocus).rays;
+                    let request, imagePointMm, distortionAreaFactor;
+                    if (k.lensMapping !== undefined) {
+                        // The full planner's own mapped query, with the same input; only its result envelope is not kept.
+                        const query = calculateMappedSensorEnvironmentRadianceQuery({ ...motion, sourcePointNativeSensorMm: point, focalLengthMm, focus: k.focus,
+                            timeSecondsFromOpeningReference: time, request: { schemaVersion: "0.1.0", sampleId, providerProfileId: base.providerProfileId, sceneId: base.sceneId,
+                                illuminationProfileId: base.illuminationProfileId, materialResponseProfileId: base.materialResponseProfileId, wavelengthNanometers: k.wavelengths[s],
+                                wavelengthBasis: base.wavelengthBasis } }, k.lensMapping).value;
+                        request = freezeOwnedData(query.request);
+                        imagePointMm = query.sourcePointImagePlaneMm;
+                        distortionAreaFactor = query.lensFieldMapping?.distortionAreaFactor;
+                        if (distortionAreaFactor === undefined)
+                            return undefined;
+                    }
+                    else {
+                        // calculateSensorEnvironmentRadianceQuery with calculateInverseCameraRotationImageMapping.
+                        imagePointMm = { x: point.x, y: -point.y };
+                        if (!Number.isFinite(imagePointMm.x) || !Number.isFinite(imagePointMm.y))
+                            return undefined;
+                        const reference = applyPhysicalCameraRotation({ x: imagePointMm.x / pd, y: imagePointMm.y / pd, z: 1 }, displacement, "camera-to-reference");
+                        if (!Number.isFinite(reference.z) || reference.z <= 0)
+                            return undefined;
+                        const rx = pd * (reference.x / reference.z), ry = pd * (reference.y / reference.z);
+                        const length = Math.hypot(rx, ry, pd);
+                        const ray = { x: rx / length, y: ry / length, z: pd / length };
+                        // Build the parseSceneRadianceEvaluationRequest output directly. Every other field is a template constant already
+                        // parsed for the template site. The sample ID is a public opaque ID (trimming cannot change it) and the time is
+                        // checked above. So only parseUnitDirection's unit-direction check depends on this site.
+                        const direction = { x: -ray.x, y: -ray.y, z: -ray.z };
+                        if (!Number.isFinite(direction.x) || !Number.isFinite(direction.y) || !Number.isFinite(direction.z))
+                            return undefined;
+                        const norm = Math.hypot(direction.x, direction.y, direction.z);
+                        if (!Number.isFinite(norm) || Math.abs(norm - 1) > 1e-9)
+                            return undefined;
+                        request = Object.freeze({ schemaVersion: "0.1.0", sampleId, providerProfileId: base.providerProfileId,
+                            sceneId: base.sceneId, illuminationProfileId: base.illuminationProfileId, materialResponseProfileId: base.materialResponseProfileId,
+                            target: Object.freeze({ kind: "environment-direction", outgoingDirectionUnitVector: Object.freeze(direction) }),
+                            timeSecondsFromExposureStart: time, wavelengthNanometers: k.wavelengths[s],
+                            wavelengthBasis: base.wavelengthBasis });
+                    }
+                    const f = destinationFields === undefined ? tapFields[gi][pi] : destinationFields[gi % P];
+                    // Built without object spread (cheaper per tap); optional fields are added only when present.
+                    const leanTap = { request, sourcePointImagePlaneMm: imagePointMm, fieldThroughput: f.value, fieldFactor: f.factor, fieldValid: f.valid };
+                    if (apertureRays !== undefined)
+                        leanTap.apertureRays = apertureRays;
+                    if (distortionAreaFactor !== undefined)
+                        leanTap.distortionAreaFactor = distortionAreaFactor;
+                    taps.push(leanTap);
+                }
+            }
+            instants.push({ time, taps });
+        }
+        return { lean: true, template: t, index, owned: environment, count: k.count, site: { x, y }, start, end, duration, instants,
+            ...(k.psf === undefined ? {} : { kernels }) };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Lean photo-signal arithmetic over values[ti][s*P+p]. Returns undefined when any data-dependent check fails. */
+function photo(k, c, values, environment, site, start, end, duration, times) {
+    const S = k.spectralCount, P = k.spatialCount, T = k.temporalCount;
+    const photonRates = new Float64Array(T), electronRates = new Float64Array(T);
+    const flux = new Float64Array(S), contribution = new Float64Array(S), averageContribution = new Float64Array(S);
+    for (let ti = 0; ti < T; ti++) {
+        const v = values[ti];
+        // reduceSensorSpatioSpectralIrradiance
+        let integratedAverage = 0, integratedFlux = 0;
+        for (let s = 0; s < S; s++) {
+            let average = 0, geometric = 0;
+            for (let p = 0; p < P; p++) {
+                const value = v[s * P + p];
+                average += value * c.weight[p];
+                geometric += value * c.areaSquareMeters[p];
+                if (!Number.isFinite(average) || !Number.isFinite(geometric))
+                    return undefined;
+            }
+            const averageTerm = average * c.measure[s], fluxTerm = geometric * c.measure[s];
+            integratedAverage += averageTerm;
+            integratedFlux += fluxTerm;
+            if (!Number.isFinite(integratedAverage) || !Number.isFinite(integratedFlux))
+                return undefined;
+            flux[s] = geometric;
+            contribution[s] = fluxTerm;
+            averageContribution[s] = averageTerm;
+        }
+        // assessSensorResponseOperatingRange: selected metric and per-bin values inside the calibrated range.
+        const metric = c.rangeKind === "power" ? integratedFlux : integratedAverage;
+        if (!Number.isFinite(metric) || metric < 0 || metric < c.rangeMinimum || metric > c.rangeMaximum)
+            return undefined;
+        if (c.perBin)
+            for (let s = 0; s < S; s++) {
+                const value = c.rangeKind === "power" ? contribution[s] : averageContribution[s];
+                if (!Number.isFinite(value) || value < 0 || value < c.rangeMinimum || value > c.rangeMaximum)
+                    return undefined;
+            }
+        // calculateSensorEqeElectronRate: reduction node checks, compensated power, then per-node rates.
+        let powerSum = 0, powerCorrection = 0;
+        for (let s = 0; s < S; s++) {
+            const expected = flux[s] * c.measure[s];
+            if (!Number.isFinite(flux[s]) || flux[s] < 0 || !Number.isFinite(contribution[s]) || contribution[s] < 0 ||
+                !Number.isFinite(expected) || !approximatelyEqual(contribution[s], expected))
+                return undefined;
+            const adjusted = contribution[s] - powerCorrection, next = powerSum + adjusted;
+            powerCorrection = (next - powerSum) - adjusted;
+            powerSum = next;
+        }
+        if (!(Number.isFinite(integratedFlux) && integratedFlux >= 0) || !approximatelyEqual(powerSum, integratedFlux))
+            return undefined;
+        let photonSum = 0, photonCorrection = 0, electronSum = 0, electronCorrection = 0;
+        for (let s = 0; s < S; s++) {
+            const radiantPower = flux[s] * c.measure[s];
+            const photonRate = radiantPower / c.photonEnergy[s];
+            const electronRate = photonRate * c.eqe[s];
+            if (!Number.isFinite(radiantPower) || !Number.isFinite(photonRate) || !Number.isFinite(electronRate))
+                return undefined;
+            const adjustedPhotons = photonRate - photonCorrection, nextPhotons = photonSum + adjustedPhotons;
+            photonCorrection = (nextPhotons - photonSum) - adjustedPhotons;
+            photonSum = nextPhotons;
+            const adjustedElectrons = electronRate - electronCorrection, nextElectrons = electronSum + adjustedElectrons;
+            electronCorrection = (nextElectrons - electronSum) - adjustedElectrons;
+            electronSum = nextElectrons;
+        }
+        if (!Number.isFinite(photonSum) || !Number.isFinite(electronSum))
+            return undefined;
+        photonRates[ti] = photonSum;
+        electronRates[ti] = electronSum;
+    }
+    // sumTemporalEqeRateExpectations with the binding's seconds-valued measure.
+    const measure = duration / T;
+    let photons = 0, electrons = 0, photonCorrection = 0, electronCorrection = 0;
+    for (let ti = 0; ti < T; ti++) {
+        const p = photonRates[ti] * measure, e = electronRates[ti] * measure;
+        const ap = p - photonCorrection, np = photons + ap;
+        photonCorrection = (np - photons) - ap;
+        photons = np;
+        const ae = e - electronCorrection, ne = electrons + ae;
+        electronCorrection = (ne - electrons) - ae;
+        electrons = ne;
+    }
+    // parseSensorEqeTemporalPhotoSignal: finite non-negative rates, EQE domain and finite counts.
+    for (let ti = 0; ti < T; ti++) {
+        const pr = photonRates[ti], er = electronRates[ti];
+        if (!Number.isFinite(pr) || pr < 0 || !Number.isFinite(er) || er < 0 || er > pr)
+            return undefined;
+    }
+    if (!Number.isFinite(photons) || photons < 0 || !Number.isFinite(electrons) || electrons < 0)
+        return undefined;
+    const temporalSamples = [];
+    for (let ti = 0; ti < T; ti++)
+        temporalSamples.push(Object.freeze({ timeSecondsFromOpeningReference: times[ti],
+            incidentPhotonRatePerSecond: photonRates[ti], expectedGeneratedElectronRatePerSecond: electronRates[ti] }));
+    return Object.freeze({ ...c.photo, temporalIntegrationId: environment.temporalIntegrationId, site: Object.freeze({ x: site.x, y: site.y }),
+        startOffsetSecondsFromOpeningReference: start, endOffsetSecondsFromOpeningReference: end, localExposureDurationSeconds: duration,
+        expectedIncidentPhotonCount: photons, expectedGeneratedElectronCount: electrons, temporalSamples: Object.freeze(temporalSamples) });
+}
+/** The temporal photo-signal input the full executor builds from these irradiance values (a PSF quadrature's nodes are equal plain data). */
+function fullPhotoInput(k, values, environment, times) {
+    return { temporalIntegrationId: environment.temporalIntegrationId, exposure: { ...environment.sensor, samples: values.map((v, ti) => ({
+                temporalSampleIndex: ti, timeSecondsFromOpeningReference: times[ti],
+                irradianceSamples: k.nodes.map((node, gi) => ({ node: structuredClone(node), spectralIrradianceWattsPerSquareMeterPerNanometer: v[gi] }))
+            })) } };
+}
+/** Derives a template's plan constants from its full plan; throws when anything is outside the lean scope. */
+function planConstants(environment, plan) {
+    const e = environment, sensor = e.sensor, spatial = sensor.spatialSampling;
+    const apertureProfile = spatial.samplingApertureProfile;
+    const aperture = apertureProfile.geometricSensitiveAperture, lattice = apertureProfile.siteCenterLattice;
+    const first = lattice.firstSiteCenterFromImagingAreaTopLeftMicrometers;
+    const offset = aperture.centerOffsetFromSiteCenterMicrometers;
+    const imaging = spatial.imagingArea;
+    const spatialNodes = plan.spatialQuadrature.nodes, spectralNodes = plan.spectralQuadrature.nodes;
+    const countX = spatial.spatialSampleCountX, countY = spatial.spatialSampleCountY;
+    const S = spectralNodes.length, P = spatialNodes.length, T = plan.instants.length, groups = plan.instants[0].groups;
+    const tapCounts = groups.map(group => group.taps.length), taps = tapCounts.reduce((sum, n) => sum + n, 0);
+    const pupilCount = plan.count / (taps * T);
+    const psf = e.psf, sampled = psf.kind === "sampled-local";
+    if (!Number.isSafeInteger(pupilCount) || pupilCount < 1 || groups.length !== S * P || (!sampled && psf.kind !== "not-applied") ||
+        (sampled && pupilCount !== 1) || (!sampled && tapCounts.some(n => n !== 1)) ||
+        plan.instants.some(i => i.groups.length !== S * P || i.groups.some((g, gi) => g.taps.length !== tapCounts[gi]))) {
+        throw new Error("outside lean scope");
+    }
+    const configuration = sampled ? psf.configuration.psf : undefined;
+    return {
+        spectralCount: S, spatialCount: P, temporalCount: T, pupilCount, count: plan.count, tapCounts,
+        tapOffsets: tapCounts.reduce((offsets, n) => { offsets.push(offsets[offsets.length - 1] + n); return offsets; }, [0]),
+        ...(configuration === undefined ? {} : { psf: { profile: configuration.profile, focalLengthMm: configuration.focalLengthMm, focus: configuration.focus,
+                apertureFNumber: configuration.apertureFNumber, signedDefocusImagePlaneMicrometers: configuration.signedDefocusImagePlaneMicrometers } }),
+        ...("lensFieldMapping" in e ? { lensMapping: prepareEnvironmentLensFieldMapping(e.lensFieldMapping) } : {}),
+        wavelengths: Float64Array.from(spectralNodes, n => n.wavelengthNanometers),
+        nodes: groups.map(group => freezeOwnedData(structuredClone(group.node))),
+        spatial: spatialNodes.map(n => ({ xPhase: (n.apertureSampleXIndex + 0.5) / countX, yPhase: (n.apertureSampleYIndex + 0.5) / countY,
+            aaX: n.antiAliasingOffsetMicrometers.x / 1000, aaY: n.antiAliasingOffsetMicrometers.y / 1000 })),
+        geometry: { firstX: first.x, firstY: first.y, pitchX: lattice.pitchXMicrometers, pitchY: lattice.pitchYMicrometers,
+            offsetX: offset.x, offsetY: offset.y, widthUm: aperture.widthMicrometers, heightUm: aperture.heightMicrometers,
+            imagingWidthMm: imaging.widthMm, imagingHeightMm: imaging.heightMm },
+        sampler: prepareCaptureExposureWindowSampler(sensor.localExposure.exposureWindowInput),
+        projectionDistanceMm: resolveProjectionDistanceMm(e.optics.focalLengthMm, plan.focus.kind === "finite" ? plan.focus.distanceM : undefined).projectionDistanceMm,
+        focus: plan.focus,
+        parsedFocus: parseFocusPlane(plan.focus),
+        requestBase: { providerProfileId: plan.sceneBindings.providerProfile.profileId, sceneId: plan.sceneBindings.providerProfile.sceneId,
+            illuminationProfileId: plan.sceneBindings.illuminationProfile.profileId, materialResponseProfileId: plan.sceneBindings.materialResponseProfile.profileId,
+            wavelengthBasis: plan.spectralQuadrature.wavelengthBasis },
+        sceneBindings: plan.sceneBindings
+    };
+}
+/** The lean planner must reproduce the template site's full plan bit for bit, including each resolved PSF kernel. */
+function planReproduced(lean, plan, k) {
+    if (!lean || lean.count !== plan.count || lean.instants.length !== plan.instants.length || (lean.kernels !== undefined) !== (k.psf !== undefined))
+        return false;
+    const check = new WeakMap();
+    for (let ti = 0; ti < plan.instants.length; ti++) {
+        const full = plan.instants[ti], mine = lean.instants[ti];
+        if (!Object.is(full.time, mine.time) || full.temporalSampleIndex !== ti || full.groups.length !== k.tapCounts.length ||
+            mine.taps.length !== k.tapOffsets[k.tapCounts.length])
+            return false;
+        for (let gi = 0; gi < full.groups.length; gi++) {
+            const fullTaps = full.groups[gi].taps, first = k.tapOffsets[gi];
+            if (fullTaps.length !== k.tapCounts[gi] || !sameData(full.groups[gi].node, k.nodes[gi], check))
+                return false;
+            for (let pi = 0; pi < fullTaps.length; pi++) {
+                const fullTap = fullTaps[pi], tap = mine.taps[first + pi];
+                if (!Object.isFrozen(fullTap.request) || !Object.isFrozen(tap.request) || !sameData(fullTap.request, tap.request, check) ||
+                    !sameData(fullTap.sourcePointImagePlaneMm, tap.sourcePointImagePlaneMm, check) ||
+                    !sameData(fullTap.fieldThroughput, tap.fieldThroughput, check) || !sameData(fullTap.apertureRays, tap.apertureRays, check) ||
+                    !Object.is(fullTap.distortionAreaFactor, tap.distortionAreaFactor))
+                    return false;
+            }
+        }
+    }
+    if (k.psf !== undefined) {
+        // Each kernel must equal the public resolver's kernel for the template site's destination and wavelength.
+        const S = k.spectralCount, P = k.spatialCount;
+        for (let gi = 0; gi < S * P; gi++) {
+            const destination = plan.spatialQuadrature.nodes[gi % P].preAntiAliasingSourcePointMm;
+            const kernel = resolveLensSampledPsf({ ...k.psf, wavelengthNm: k.wavelengths[Math.floor(gi / P)],
+                fieldPointMm: { x: destination.x, y: -destination.y } }).value.kernel;
+            if (!sameData(kernel.normalizedIntensity, lean.kernels[gi], check))
+                return false;
+        }
+    }
+    return true;
+}
+/** Sum of a PSF group's taps in kernel order, the same expression calculateSensorPsfIrradianceQuadrature reduces. */
+function psfSum(kernel, values) {
+    let sum = 0;
+    for (let i = 0; i < values.length; i++)
+        sum = sum + kernel[i] * values[i];
+    return sum;
+}
+/**
+ * True when every data-dependent check calculateSensorPsfIrradianceQuadrature makes on one instant passes: finite,
+ * non-negative tap irradiances, finite weighted sums, and the finite partial sums of its spatio-spectral reduction
+ * (in the reduction's node order). When false, the full quadrature runs and decides.
+ */
+function psfChecksPass(k, c, taps, v) {
+    for (const values of taps)
+        for (let i = 0; i < values.length; i++)
+            if (!Number.isFinite(values[i]) || values[i] < 0)
+                return false;
+    const S = k.spectralCount, P = k.spatialCount;
+    let integratedAverage = 0, integratedFlux = 0;
+    for (let s = 0; s < S; s++) {
+        let average = 0, geometric = 0;
+        for (let p = 0; p < P; p++) {
+            const value = v[s * P + p];
+            if (!Number.isFinite(value) || value < 0)
+                return false;
+            average += value * c.weight[p];
+            geometric += value * c.areaSquareMeters[p];
+            if (!Number.isFinite(average) || !Number.isFinite(geometric))
+                return false;
+        }
+        integratedAverage += average * c.measure[s];
+        integratedFlux += geometric * c.measure[s];
+        if (!Number.isFinite(integratedAverage) || !Number.isFinite(integratedFlux))
+            return false;
+    }
+    return true;
+}
+/** The full executor's PSF quadrature for one instant of a site's full plan, with the given tap irradiances. Throws its own errors. */
+function fullPsfInstant(plan, ti, taps) {
+    nativeEnvironmentLeanStatistics.psfFallbacks++;
+    const instant = plan.instants[ti], owned = plan.owned;
+    if (owned.psf.kind !== "sampled-local")
+        throw new InvalidConfigurationError("Lean PSF fallback requires a sampled-PSF plan.");
+    const psf = calculateSensorPsfIrradianceQuadrature({ ...owned.psf.configuration, spatialQuadrature: plan.spatialQuadrature,
+        spectralQuadrature: plan.spectralQuadrature, timeSecondsFromOpeningReference: instant.time,
+        inputMeaning: "pre-psf-pre-sensor-stack-pre-aa-spectral-irradiance", samples: instant.groups.map((group, gi) => ({ node: group.node,
+            sourceSamples: group.taps.map((tap, pi) => ({ kernelSampleX: tap.kernelSampleX, kernelSampleY: tap.kernelSampleY, sourcePointNativeSensorMm: tap.point,
+                timeSecondsFromOpeningReference: instant.time, spectralIrradianceWattsPerSquareMeterPerNanometer: taps[gi][pi] })) })) });
+    return Float64Array.from(psf.value.irradianceSamples, sample => sample.spectralIrradianceWattsPerSquareMeterPerNanometer);
+}
+/** Derives execution constants from the template site's full execution ("full" retention) and checks them. Returns undefined on a mismatch. */
+function executionConstants(k, environment, plan, result, self) {
+    const S = k.spectralCount, P = k.spatialCount, T = k.temporalCount;
+    const value = result.value, stages = value.photo.value.exposure.value.samples[0].stages;
+    const spatial = stages.spatialQuadrature.value.nodes, spectral = stages.spectralQuadrature.value.nodes;
+    const rate = stages.electronRate.value.perWavelength, range = stages.operatingRange.value;
+    if (spatial.length !== P || spectral.length !== S || rate.length !== S || value.instants.length !== T)
+        return undefined;
+    for (let s = 0; s < S; s++)
+        if (rate[s].spectralSampleIndex !== s || spectral[s].spectralSampleIndex !== s)
+            return undefined;
+    const c = {
+        weight: Float64Array.from(spatial, n => n.combinedNormalizedSpatialWeight),
+        areaSquareMeters: Float64Array.from(spatial, n => n.combinedAreaMeasureSquareMicrometers * SQUARE_MICROMETERS_TO_SQUARE_METERS),
+        measure: Float64Array.from(spectral, n => n.wavelengthMeasureNanometers),
+        photonEnergy: Float64Array.from(rate, n => n.photonEnergyJoules), eqe: Float64Array.from(rate, n => n.effectiveExternalQuantumEfficiency),
+        acceptance: new Float64Array(S).fill(NaN),
+        rangeKind: range.inputRange.kind === "wavelength-integrated-geometric-aperture-radiant-power" ? "power" : "irradiance",
+        rangeMinimum: range.inputRange.minimumInclusive, rangeMaximum: range.inputRange.maximumInclusive,
+        perBin: range.spectralInputModel.kind === "per-spectral-bin", photo: value.photo.value.photoSignal
+    };
+    // Acceptance before field throughput per wavelength, and every evaluation's irradiance, must reproduce exactly.
+    // With a PSF, each group's kernel-weighted sum must equal the full quadrature's node irradiance.
+    const values = [];
+    const check = new WeakMap();
+    for (let ti = 0; ti < T; ti++) {
+        const evaluations = value.instants[ti].evaluations, v = new Float64Array(S * P), psf = value.instants[ti].psf;
+        if ((psf !== null) !== (k.psf !== undefined))
+            return undefined;
+        let next = 0;
+        for (let gi = 0; gi < S * P; gi++) {
+            const s = Math.floor(gi / P), taps = plan.instants[ti].groups[gi].taps, tapValues = new Float64Array(taps.length);
+            for (let pi = 0; pi < taps.length; pi++) {
+                const request = taps[pi].request;
+                let integrated = 0;
+                for (let r = 0; r < k.pupilCount; r++) {
+                    const evaluation = evaluations[next++];
+                    if (!evaluation)
+                        return undefined;
+                    const o = evaluation.optics.value;
+                    let a = o.transmissionPath === "spectral-transmission" ? o.paraxialGeometricAcceptanceSolidAngleSteradians * o.spectralTransmissionFactor
+                        : Math.PI / (4 * o.effectiveWorkingTStop * o.effectiveWorkingTStop);
+                    a *= o.frontOfLensFilterTransmissionFactor;
+                    if (Number.isNaN(c.acceptance[s]))
+                        c.acceptance[s] = a;
+                    else if (!Object.is(c.acceptance[s], a))
+                        return undefined;
+                    const acceptance = c.acceptance[s] * o.fieldThroughputFactor;
+                    const irradiance = evaluation.result.spectralRadianceWattsPerSquareMeterSteradianNanometer * acceptance;
+                    if (!Object.is(acceptance, o.effectiveAcceptanceAfterTransmissionAndFieldSteradians) ||
+                        !Object.is(irradiance, o.sensorPlaneSpectralIrradianceWattsPerSquareMeterNanometer) ||
+                        evaluation.result.sampleId !== request.sampleId + (evaluation.apertureRay ? "-a" + evaluation.apertureRay.pupilSampleIndex : ""))
+                        return undefined;
+                    integrated += irradiance * (evaluation.apertureRay?.weight ?? 1);
+                }
+                const factor = taps[pi].distortionAreaFactor;
+                if (factor !== undefined)
+                    integrated *= factor;
+                tapValues[pi] = integrated;
+            }
+            if (psf === null)
+                v[gi] = tapValues[0];
+            else {
+                const sample = psf.value.irradianceSamples[gi];
+                v[gi] = psfSum(self.kernels[gi], tapValues);
+                if (!sample || !Object.is(v[gi], sample.spectralIrradianceWattsPerSquareMeterPerNanometer) || !sameData(sample.node, k.nodes[gi], check))
+                    return undefined;
+            }
+        }
+        if (next !== evaluations.length)
+            return undefined;
+        values.push(v);
+    }
+    if (c.acceptance.some(Number.isNaN))
+        return undefined;
+    const full = value.photo.value.photoSignal;
+    const mine = photo(k, c, values, environment, full.site, full.startOffsetSecondsFromOpeningReference, full.endOffsetSecondsFromOpeningReference, full.localExposureDurationSeconds, plan.instants.map(i => i.time));
+    return mine && sameData(mine, full, new WeakMap()) ? c : undefined;
+}
+export function createNativeEnvironmentLeanExecutor(frame) {
+    const templates = [];
+    const candidates = new Map();
+    const memo = new WeakMap();
+    const enabled = !leanDisabled && frame.identityBinding && frame.repeatWidth > 0 && frame.repeatHeight > 0;
+    const phaseOf = (index) => {
+        const x = index % frame.nativeWidth, y = Math.floor(index / frame.nativeWidth);
+        return (y % frame.repeatHeight) * frame.repeatWidth + (x % frame.repeatWidth);
+    };
+    return {
+        plan(environment, index) {
+            if (!enabled)
+                return undefined;
+            const phase = phaseOf(index);
+            let t;
+            try {
+                for (const template of templates)
+                    if (template.phase === phase && environmentMatches(environment, template.environment, memo)) {
+                        t = template;
+                        break;
+                    }
+            }
+            catch {
+                return undefined;
+            }
+            if (!t)
+                return templates.length < MAXIMUM_TEMPLATES ? "candidate" : undefined;
+            if (t.disabled || !t.consts || t.executionVerified === false)
+                return undefined;
+            const leanPlan = geometry(t, t.consts, frame, environment, index);
+            if (leanPlan)
+                nativeEnvironmentLeanStatistics.plannedSites++;
+            return leanPlan;
+        },
+        admitCandidate(environment, index, plan) {
+            const template = { environment, phase: phaseOf(index), disabled: true };
+            templates.push(template);
+            candidates.set(index, template);
+            try {
+                const k = planConstants(environment, plan), self = geometry(template, k, frame, environment, index);
+                if (!planReproduced(self, plan, k))
+                    return;
+                template.consts = k;
+                template.selfPlan = self;
+                template.disabled = false;
+            }
+            catch {
+                // An ineligible template leaves its sites on the full path.
+            }
+        },
+        isCandidate(index) { return candidates.has(index); },
+        verifyCandidate(index, plan, result) {
+            const t = candidates.get(index);
+            if (!t)
+                return;
+            candidates.delete(index);
+            t.executionVerified = false;
+            try {
+                if (t.disabled || !t.consts || !t.selfPlan)
+                    return;
+                const c = executionConstants(t.consts, t.environment, plan, result, t.selfPlan);
+                t.selfPlan = undefined;
+                if (!c)
+                    return;
+                t.execution = c;
+                t.executionVerified = true;
+            }
+            catch {
+                // Unverified: sites of this template run the full path.
+            }
+        },
+        execute(plan, evaluate, aperture, fullPlan) {
+            const t = plan.template, c = t.execution, k = t.consts;
+            if (t.executionVerified !== true || !c || !k)
+                return undefined;
+            const environment = plan.owned, optics = environment.optics;
+            const S = k.spectralCount, P = k.spatialCount, kernels = plan.kernels;
+            /** One tap: its callbacks in order, each result validated, the pupil sum, then the distortion area factor once. */
+            const tapIrradiance = (tap, s) => {
+                let integrated = 0;
+                const support = tap.apertureRays ?? [undefined];
+                for (const ray of support) {
+                    const query = ray === undefined ? undefined : apertureRadianceQuery(tap.request, ray);
+                    const request = query === undefined ? tap.request : query.request, apertureRay = query?.apertureRay;
+                    const result = parseSceneRadianceEvaluationResult(apertureRay === undefined ? evaluate(request) : aperture(request, apertureRay));
+                    if (result.sampleId !== request.sampleId || result.providerProfileId !== request.providerProfileId || result.sceneId !== request.sceneId ||
+                        result.wavelengthNanometers !== request.wavelengthNanometers || result.wavelengthBasis !== request.wavelengthBasis) {
+                        validateSceneRadianceEvaluationBindings({ ...k.sceneBindings, request, result });
+                    }
+                    let irradiance = result.spectralRadianceWattsPerSquareMeterSteradianNanometer * (c.acceptance[s] * tap.fieldFactor);
+                    if (!tap.fieldValid || !Number.isFinite(irradiance) || irradiance < 0) {
+                        irradiance = calculateSceneRadianceToSensorIrradiance({ ...optics,
+                            sceneRadianceRequest: request, sceneRadianceResult: result, imagePointMm: tap.sourcePointImagePlaneMm,
+                            fieldThroughput: tap.fieldThroughput }).value.sensorPlaneSpectralIrradianceWattsPerSquareMeterNanometer;
+                    }
+                    integrated += irradiance * (ray?.weight ?? 1);
+                }
+                // Distortion squeezes or stretches the ideal image; irradiance scales by 1/det once, as in the full executor.
+                if (tap.distortionAreaFactor !== undefined)
+                    integrated *= tap.distortionAreaFactor;
+                return integrated;
+            };
+            const values = [], times = [];
+            let full;
+            for (let ti = 0; ti < plan.instants.length; ti++) {
+                const instant = plan.instants[ti];
+                let v = new Float64Array(S * P);
+                if (kernels === undefined) {
+                    // One tap per group, so the flat list is indexed by group.
+                    for (let gi = 0; gi < S * P; gi++)
+                        v[gi] = tapIrradiance(instant.taps[gi], Math.floor(gi / P));
+                }
+                else {
+                    const tapValues = [];
+                    for (let gi = 0; gi < S * P; gi++) {
+                        const first = k.tapOffsets[gi], s = Math.floor(gi / P), groupValues = new Float64Array(k.tapOffsets[gi + 1] - first);
+                        for (let pi = 0; pi < groupValues.length; pi++)
+                            groupValues[pi] = tapIrradiance(instant.taps[first + pi], s);
+                        tapValues.push(groupValues);
+                        v[gi] = psfSum(kernels[gi], groupValues);
+                    }
+                    // The full executor runs its PSF quadrature (and its checks) here, after this instant's callbacks. When a check
+                    // fails, run that quadrature on the site's full plan (built without callbacks): it throws its own error or decides.
+                    if (!psfChecksPass(k, c, tapValues, v))
+                        v = fullPsfInstant(full ??= fullPlan(), ti, tapValues);
+                }
+                values.push(v);
+                times.push(instant.time);
+            }
+            nativeEnvironmentLeanStatistics.executedSites++;
+            return photo(k, c, values, environment, plan.site, plan.start, plan.end, plan.duration, times) ??
+                createSensorEqeTemporalPhotoSignal(fullPhotoInput(k, values, environment, times)).value.photoSignal;
+        }
+    };
+}
+function approximatelyEqual(actual, expected) {
+    const scale = Math.max(1, Math.abs(actual), Math.abs(expected));
+    return Math.abs(actual - expected) <= REDUCTION_TOLERANCE * scale;
+}
+/** Photo-signal fields that vary per site; every other field is template-level. */
+const PHOTO_SITE_FIELDS = new Set(["temporalIntegrationId", "site", "startOffsetSecondsFromOpeningReference",
+    "endOffsetSecondsFromOpeningReference", "localExposureDurationSeconds", "expectedIncidentPhotonCount", "expectedGeneratedElectronCount", "temporalSamples"]);
+const SITE_ONLY = new Set(["site"]);
+const SITE_APPLICABILITY = new Set(["siteApplicability"]);
+const COMPLETENESS = new Set(["completenessProfile"]);
+const CAPACITY = new Set(["capacityProfile"]);
+const COMPLETENESS_SITE_FIELDS = new Set(["site", "startOffsetSecondsFromOpeningReference", "endOffsetSecondsFromOpeningReference"]);
+/** Same own keys in the same order; values strictly equal except `skip` keys (compared by the caller). */
+function sameRecordExcept(a, b, skip, memo) {
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null || Array.isArray(a) || Array.isArray(b) ||
+        !isPlainRecord(a) || !isPlainRecord(b))
+        return false;
+    const ar = a, br = b, ak = Object.keys(ar), bk = Object.keys(br);
+    if (ak.length !== bk.length || Object.getOwnPropertySymbols(ar).length !== 0 || Object.getOwnPropertySymbols(br).length !== 0)
+        return false;
+    for (let i = 0; i < ak.length; i++)
+        if (ak[i] !== bk[i])
+            return false;
+    for (const key of ak)
+        if (!skip.has(key) && !sameData(ar[key], br[key], memo))
+            return false;
+    return true;
+}
+/** A plain {x, y} record equal (Object.is) to the given coordinates. */
+function siteSlot(value, x, y) {
+    if (typeof value !== "object" || value === null || Array.isArray(value) || !isPlainRecord(value))
+        return false;
+    const keys = Object.keys(value), r = value;
+    return keys.length === 2 && keys[0] === "x" && keys[1] === "y" && Object.is(r.x, x) && Object.is(r.y, y) && Object.getOwnPropertySymbols(value).length === 0;
+}
+/** A record whose optional `site` key (the only one skipped) holds each side's own coordinates. */
+function sameWithSiteSlot(a, b, ax, ay, bx, by, memo) {
+    if (!sameRecordExcept(a, b, SITE_ONLY, memo))
+        return false;
+    const ar = a, br = b;
+    return !("site" in ar) || (siteSlot(ar.site, ax, ay) && siteSlot(br.site, bx, by));
+}
+/** Sensor-site equality except the index-bound site slots and the per-site photo numbers. */
+function sensorMatches(site, photo, x, y, t, memo) {
+    const a = site, b = t.site;
+    if (typeof a !== "object" || a === null || !isPlainRecord(a))
+        return false;
+    const ak = Object.keys(a), bk = Object.keys(b);
+    if (ak.length !== bk.length || Object.getOwnPropertySymbols(a).length !== 0)
+        return false;
+    for (let i = 0; i < ak.length; i++)
+        if (ak[i] !== bk[i])
+            return false;
+    for (const key of ak) {
+        if (key === "environment")
+            continue;
+        if (key === "darkCurrentProfile") {
+            const ad = a.darkCurrentProfile, bd = b.darkCurrentProfile;
+            if (!sameRecordExcept(ad, bd, SITE_APPLICABILITY, memo) ||
+                !sameWithSiteSlot(ad.siteApplicability, bd.siteApplicability, x, y, t.x, t.y, memo))
+                return false;
+        }
+        else if (key === "charge") {
+            const ac = a.charge, bc = b.charge;
+            if (!sameRecordExcept(ac, bc, COMPLETENESS, memo) || "additionalChargeComponents" in ac)
+                return false;
+            const ap = ac.completenessProfile, bp = bc.completenessProfile;
+            if (!sameRecordExcept(ap, bp, COMPLETENESS_SITE_FIELDS, memo) || !siteSlot(ap.site, x, y) || !siteSlot(bp.site, t.x, t.y) ||
+                ap.startOffsetSecondsFromOpeningReference !== photo.startOffsetSecondsFromOpeningReference ||
+                ap.endOffsetSecondsFromOpeningReference !== photo.endOffsetSecondsFromOpeningReference)
+                return false;
+        }
+        else if (key === "readout") {
+            const ar = a.readout, br = b.readout;
+            if (!sameRecordExcept(ar, br, CAPACITY, memo))
+                return false;
+            const ac = ar.capacityProfile, bc = br.capacityProfile;
+            if (!sameRecordExcept(ac, bc, SITE_APPLICABILITY, memo) ||
+                !sameWithSiteSlot(ac.siteApplicability, bc.siteApplicability, x, y, t.x, t.y, memo))
+                return false;
+        }
+        else if (!sameData(a[key], b[key], memo))
+            return false;
+    }
+    return sameRecordExcept(photo, t.photo, PHOTO_SITE_FIELDS, memo) && siteSlot(photo.site, x, y) &&
+        photo.temporalSamples.length === t.photo.temporalSamples.length;
+}
+/** The sensor stage of calculateNativeRawSite, in the same operation order. Returns undefined when one of its checks would throw. */
+function leanSensorSite(t, h, index, seed) {
+    const ratio = h.total / t.capacity, headroom = t.capacity - h.total;
+    if (!Number.isFinite(ratio) || !Number.isFinite(headroom))
+        return undefined;
+    const pattern = t.pattern === undefined ? null : evaluateParsedFixedPatternSite(t.pattern, { x: h.x, y: h.y });
+    const photoE = h.photo.expectedGeneratedElectronCount;
+    const photoMean = pattern === null ? photoE : photoE * pattern.photoResponseGainFactor;
+    const darkMean = pattern === null ? h.darkE : h.darkE * pattern.darkCurrentFactor;
+    if (!Number.isFinite(photoMean) || photoMean < 0 || !Number.isFinite(darkMean) || darkMean < 0)
+        return undefined;
+    const random = createDeterministicUniformStream(deriveNativeSiteStreamSeedUint32(seed, index, NATIVE_SITE_CHARGE_STREAM_ID));
+    const photoRealized = samplePoisson(photoMean, random), darkRealized = samplePoisson(darkMean, random);
+    const realized = photoRealized + darkRealized + 0;
+    if (!Number.isFinite(realized) || realized < 0)
+        return undefined;
+    const readRandom = createDeterministicUniformStream(deriveNativeSiteStreamSeedUint32(seed, index, NATIVE_SITE_READ_NOISE_STREAM_ID));
+    const regime = t.readout.regime, capacity = t.capacity;
+    const afterPhysical = Math.min(realized, capacity), physicalSaturation = afterPhysical < realized;
+    const sampled = regime.readNoiseComponents.map(component => component.rmsElectrons.value === 0 ? 0 :
+        sampleDeterministicStandardNormal(readRandom) * component.rmsElectrons.value);
+    let totalReadNoise = 0;
+    for (const value of sampled)
+        totalReadNoise = totalReadNoise + value;
+    const afterReadNoise = afterPhysical + totalReadNoise + (pattern === null ? 0 : pattern.readoutOffsetElectrons);
+    const threshold = regime.preAdcSaturationElectronEquivalent.value;
+    const afterPreAdc = Math.min(afterReadNoise, threshold), preAdcSaturation = afterReadNoise > threshold;
+    const quantized = adcTransfer(regime, t.readout.adcMaximumCode, afterPreAdc).quantized;
+    const digitalSaturationCode = regime.adc.digitalSaturationCode;
+    return { rawCode: Math.max(0, Math.min(quantized, digitalSaturationCode)), blackLevelCode: regime.adc.blackLevelCode, digitalSaturationCode,
+        flags: Number(physicalSaturation) | Number(preAdcSaturation) << 1 | Number(quantized >= digitalSaturationCode) << 2,
+        whiteCode: t.whiteCode, photoRealized, darkRealized };
+}
+/** The Kahan (compensated) total that composeSensorAccumulatedCharge computes, for photo and dark charge only. */
+function chargeTotal(photoE, darkE) {
+    let sum = 0, correction = 0;
+    for (const value of [photoE, darkE]) {
+        const adjusted = value - correction, next = sum + adjusted;
+        correction = (next - sum) - adjusted;
+        sum = next;
+    }
+    return sum;
+}
+export function createNativeEnvironmentSensorLean(frame, producerFrame, nativeWindow) {
+    const enabled = !leanDisabled && nativeWindow !== undefined && frame.identityBinding && frame.repeatWidth > 0 && frame.repeatHeight > 0;
+    const templates = [], handles = new WeakMap(), memo = new WeakMap();
+    let pending = new Map();
+    const coordinates = (index) => {
+        const x = index % frame.nativeWidth, y = Math.floor(index / frame.nativeWidth);
+        return { x, y, phase: (y % frame.repeatHeight) * frame.repeatWidth + (x % frame.repeatWidth) };
+    };
+    const find = (site, photo, x, y, phase) => {
+        for (const t of templates)
+            if (t.phase === phase && sensorMatches(site, photo, x, y, t, memo))
+                return t;
+        return undefined;
+    };
+    return {
+        beginTile() { pending = new Map(); },
+        claim(site, photo, index) {
+            if (!enabled)
+                return undefined;
+            try {
+                const { x, y, phase } = coordinates(index), t = find(site, photo, x, y, phase);
+                if (!t || !t.verified)
+                    return undefined;
+                // Parse-phase predicates of the full path: EQE domain, dark and total charge, and the committed local window.
+                const photoE = photo.expectedGeneratedElectronCount, duration = photo.localExposureDurationSeconds;
+                if (!(photoE <= photo.expectedIncidentPhotonCount))
+                    return undefined;
+                const darkE = t.darkRate * duration;
+                if (!Number.isFinite(darkE) || darkE < 0)
+                    return undefined;
+                const total = chargeTotal(photoE, darkE);
+                if (!Number.isFinite(total) || total < 0)
+                    return undefined;
+                const window = nativeWindow({ x: x + .5, y: y + .5 });
+                if (photo.startOffsetSecondsFromOpeningReference !== window.startOffsetSecondsFromOpeningReference ||
+                    photo.endOffsetSecondsFromOpeningReference !== window.endOffsetSecondsFromOpeningReference ||
+                    duration !== window.localExposureDurationSeconds)
+                    return undefined;
+                const marker = Object.freeze({});
+                handles.set(marker, { template: t, site, photo, x, y, darkE, total });
+                return marker;
+            }
+            catch {
+                return undefined;
+            }
+        },
+        remember(index, site, photo) { if (enabled)
+            pending.set(index, { site, photo }); },
+        hook: {
+            claim(site) {
+                return typeof site === "object" && site !== null && handles.has(site) ? site : undefined;
+            },
+            compute(handle, index, seed, timing) {
+                const h = handles.get(handle), out = leanSensorSite(h.template, h, index, seed);
+                if (out)
+                    nativeEnvironmentLeanStatistics.sensorSites++;
+                if (out)
+                    return { rawCode: out.rawCode, blackLevelCode: out.blackLevelCode, digitalSaturationCode: out.digitalSaturationCode, flags: out.flags, whiteCode: out.whiteCode };
+                // A compute-phase check failed: the full path computes (and throws) exactly as it would have.
+                const parsed = parseNativeRawProducerSite(composeNativeEnvironmentSensorSite(h.site, h.photo), index, producerFrame, timing);
+                const r = calculateNativeRawSite(parsed, seed, index).readout.value;
+                return { rawCode: r.rawCode, blackLevelCode: r.blackLevelCode, digitalSaturationCode: r.digitalSaturationCode,
+                    flags: Number(r.physicalScalarSaturationApplied) | Number(r.preAdcSaturationApplied) << 1 | Number(r.digitalSaturationApplied) << 2,
+                    whiteCode: calculateSiteEffectiveSaturationCode(r, parsed.readoutProfile, parsed.regimeId) };
+            },
+            observe(index, parsed, result, whiteCode, seed) {
+                const entry = pending.get(index);
+                pending.delete(index);
+                if (!entry || templates.length >= MAXIMUM_TEMPLATES)
+                    return;
+                try {
+                    const { x, y, phase } = coordinates(index), { site, photo } = entry;
+                    if (find(site, photo, x, y, phase) !== undefined)
+                        return;
+                    const readout = resolveSensorReadoutRegime({ profile: parsed.readoutProfile, regimeId: parsed.regimeId });
+                    const t = { site, photo, phase, x, y, verified: false, darkRate: parsed.charge.darkCharge.darkCurrentElectronsPerSecond,
+                        capacity: result.capacity.value.physicalChargeCapacityElectrons, readout, pattern: parsed.fixedPatternNoise, whiteCode };
+                    templates.push(t);
+                    // Self-check: the template matches itself and the lean arithmetic reproduces its full computation bit for bit.
+                    if (!sensorMatches(site, photo, x, y, t, new WeakMap()))
+                        return;
+                    const darkE = t.darkRate * photo.localExposureDurationSeconds, total = chargeTotal(photo.expectedGeneratedElectronCount, darkE);
+                    const r = result.readout.value, realization = result.realization.value;
+                    const out = leanSensorSite(t, { photo, darkE, total, x, y }, index, seed);
+                    if (!out || !Object.is(darkE, parsed.charge.darkCharge.expectedDarkElectronCount) ||
+                        !Object.is(total, result.accumulatedCharge.value.totalExpectedStoredElectronCount) ||
+                        !Object.is(out.photoRealized, realization.photoRealizedElectronCount) || !Object.is(out.darkRealized, realization.darkRealizedElectronCount) ||
+                        realization.additionalComponents.length !== 0 || out.rawCode !== r.rawCode || out.blackLevelCode !== r.blackLevelCode ||
+                        out.digitalSaturationCode !== r.digitalSaturationCode || out.flags !== (Number(r.physicalScalarSaturationApplied) |
+                        Number(r.preAdcSaturationApplied) << 1 | Number(r.digitalSaturationApplied) << 2))
+                        return;
+                    t.verified = true;
+                }
+                catch {
+                    // An unverified template leaves its sites on the full path.
+                }
+            }
+        }
+    };
+}
+//# sourceMappingURL=native-environment-lean.js.map