@photivra/engine 2.19.0 → 2.21.0

package/docs/API_REFERENCE.md

@@ -1,6 +1,6 @@
 # Public API reference
 
-Generated from the exact root exports for **@photivra/engine 2.19.0 / root contract 2.19.0** by `node scripts/generate-api-reference.mjs`. No module deep import is supported.
+Generated from the exact root exports for **@photivra/engine 2.21.0 / root contract 2.21.0** by `node scripts/generate-api-reference.mjs`. No module deep import is supported.
 
 Use [the developer guide](https://github.com/Photivra/photivra/blob/main/docs/DEVELOPERS.md) for executable paths and scientific boundaries. Types are contracts, not runtime validation: parse untrusted data, preserve units/reference frames, read assessment blockers, and retain evidence/limitations. Optional properties do not imply a universal default. Model/schema IDs remain independent of the distribution.
 
@@ -15,11 +15,13 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | Exposure value and equivalent settings | [`calculateExposureValue100`](api/exposure-exposure.md#calculateexposurevalue100), [`calculateEquivalentIso`](api/exposure-exposure.md#calculateequivalentiso), [`calculateRelativeRenderedExposure`](api/exposure-exposure.md#calculaterelativerenderedexposure) |
 | Depth of field, hyperfocal distance and defocus blur | [`calculateDepthOfField`](api/optics-depth-of-field.md#calculatedepthoffield), [`calculateDefocusCircle`](api/optics-depth-of-field.md#calculatedefocuscircle) |
 | Field of view | [`calculateFieldOfView`](api/camera-field-of-view.md#calculatefieldofview) |
-| Crop factor, 35 mm-equivalent focal length and crops | [`calculateEquivalentFocalLength35Mm`](api/camera-equivalent-focal-length.md#calculateequivalentfocallength35mm), [`calculateCenteredCrop`](api/output-crop.md#calculatecenteredcrop) |
+| Crop factor, 35 mm-equivalent focal length and crops | [`calculateEquivalentFocalLength35Mm`](api/camera-equivalent-focal-length.md#calculateequivalentfocallength35mm), [`calculateCenteredCrop`](api/output-crop.md#calculatecenteredcrop), [`calculateCropToMatchFocalLength`](api/output-crop-to-match-focal-length.md#calculatecroptomatchfocallength) |
+| Aperture (entrance-pupil) diameter | [`calculateApertureDiameter`](api/optics-aperture-diameter.md#calculateaperturediameter) |
 | Equivalent f-number, sensor area and blur as a share of the frame | [`calculateSensorEquivalence`](api/camera-sensor-equivalence.md#calculatesensorequivalence), [`calculateBlurShareOfFrame`](api/camera-sensor-equivalence.md#calculateblurshareofframe) |
 | Motion blur and shutter speed | [`calculateProjectedMotionBlur`](api/motion-projected-motion.md#calculateprojectedmotionblur), [`calculateShutterAngleExposureSeconds`](api/motion-video-sequence.md#calculateshutterangleexposureseconds) |
 | Shutter time with an ND filter | [`calculateFilteredExposureTime`](api/exposure-filtered-exposure-time.md#calculatefilteredexposuretime) |
 | Diffraction | [`calculateAiryDisk`](api/optics-diffraction.md#calculateairydisk) |
+| Which limits detail: the lens or the sensor | [`calculateDetailLimit`](api/optics-detail-limit.md#calculatedetaillimit) |
 | Sensor signal, noise and SNR | [`calculatePhotoelectrons`](api/sensor-signal-noise.md#calculatephotoelectrons), [`calculateSignalToNoise`](api/sensor-signal-noise.md#calculatesignaltonoise) |
 | Colour temperature | [`calculateChromaticityFromCorrelatedColorTemperature`](api/color-illuminants.md#calculatechromaticityfromcorrelatedcolortemperature), [`calculateCorrelatedColorTemperature`](api/color-illuminants.md#calculatecorrelatedcolortemperature) |
 | White balance from Kelvin and tint | [`createColorTemperatureWhiteBalanceIntent`](api/color-white-balance.md#createcolortemperaturewhitebalanceintent), [`resolveColorTemperatureWhiteBalance`](api/color-white-balance.md#resolvecolortemperaturewhitebalance) |
@@ -974,6 +976,26 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`GenericReleaseDriveMode`](api/equipment-release-capabilities.md#genericreleasedrivemode) | Type |
 | [`parseGenericReleaseCapabilityProfile`](api/equipment-release-capabilities.md#parsegenericreleasecapabilityprofile) | Runtime |
 
+## equipment/sensor-profile-body.ts
+
+[Detailed contracts](api/equipment-sensor-profile-body.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/equipment/sensor-profile-body.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`SENSOR_PROFILE_ISO_ANCHOR`](api/equipment-sensor-profile-body.md#sensor_profile_iso_anchor) | Runtime |
+| [`SensorProfile`](api/equipment-sensor-profile-body.md#sensorprofile) | Type |
+| [`SensorProfileValueKind`](api/equipment-sensor-profile-body.md#sensorprofilevaluekind) | Type |
+
+## equipment/sensor-profiles.ts
+
+[Detailed contracts](api/equipment-sensor-profiles.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/equipment/sensor-profiles.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`resolveSensorProfile`](api/equipment-sensor-profiles.md#resolvesensorprofile) | Runtime |
+| [`SENSOR_PROFILE_IDS`](api/equipment-sensor-profiles.md#sensor_profile_ids) | Runtime |
+| [`SENSOR_PROFILES`](api/equipment-sensor-profiles.md#sensor_profiles) | Runtime |
+
 ## exposure/auto-iso-slowest-shutter.ts
 
 [Detailed contracts](api/exposure-auto-iso-slowest-shutter.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/exposure/auto-iso-slowest-shutter.ts)
@@ -1312,6 +1334,66 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`DisplayViewCorrectionStateSet`](api/facade-display-view.md#displayviewcorrectionstateset) | Type |
 | [`serializeDisplayViewCorrectionStates`](api/facade-display-view.md#serializedisplayviewcorrectionstates) | Runtime |
 
+## facade/exposure-build-up.ts
+
+[Detailed contracts](api/facade-exposure-build-up.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/facade/exposure-build-up.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`EXPOSURE_BUILD_UP_MAXIMUM_FRACTIONS`](api/facade-exposure-build-up.md#exposure_build_up_maximum_fractions) | Runtime |
+| [`EXPOSURE_BUILD_UP_STREAM_BASE`](api/facade-exposure-build-up.md#exposure_build_up_stream_base) | Runtime |
+| [`simulateExposureBuildUp`](api/facade-exposure-build-up.md#simulateexposurebuildup) | Runtime |
+| [`SimulateExposureBuildUpFrame`](api/facade-exposure-build-up.md#simulateexposurebuildupframe) | Type |
+| [`SimulateExposureBuildUpOptions`](api/facade-exposure-build-up.md#simulateexposurebuildupoptions) | Type |
+| [`SimulateExposureBuildUpResult`](api/facade-exposure-build-up.md#simulateexposurebuildupresult) | Type |
+
+## facade/fast-methods.ts
+
+[Detailed contracts](api/facade-fast-methods.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/facade/fast-methods.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`SIMULATE_CAPTURE_FAST_METHODS`](api/facade-fast-methods.md#simulate_capture_fast_methods) | Runtime |
+| [`SimulateCaptureFastMethod`](api/facade-fast-methods.md#simulatecapturefastmethod) | Type |
+
+## facade/image-plane-enable.ts
+
+[Detailed contracts](api/facade-image-plane-enable.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/facade/image-plane-enable.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`prepareImagePlaneScenes`](api/facade-image-plane-enable.md#prepareimageplanescenes) | Runtime |
+
+## facade/mixed-illumination.ts
+
+[Detailed contracts](api/facade-mixed-illumination.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/facade/mixed-illumination.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`MixedIllumination`](api/facade-mixed-illumination.md#mixedillumination) | Type |
+| [`MixedIlluminationBlend`](api/facade-mixed-illumination.md#mixedilluminationblend) | Type |
+| [`MixedIlluminationPoint`](api/facade-mixed-illumination.md#mixedilluminationpoint) | Type |
+| [`MixedIlluminationPointSource`](api/facade-mixed-illumination.md#mixedilluminationpointsource) | Type |
+| [`MixedIlluminationSource`](api/facade-mixed-illumination.md#mixedilluminationsource) | Type |
+
+## facade/representative-light-sources.ts
+
+[Detailed contracts](api/facade-representative-light-sources.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/facade/representative-light-sources.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`createRepresentativeLightSourceIlluminant`](api/facade-representative-light-sources.md#createrepresentativelightsourceilluminant) | Runtime |
+| [`createRepresentativeLightSourceSpectrum`](api/facade-representative-light-sources.md#createrepresentativelightsourcespectrum) | Runtime |
+| [`getRepresentativeLightSourceSet`](api/facade-representative-light-sources.md#getrepresentativelightsourceset) | Runtime |
+| [`REPRESENTATIVE_LIGHT_SOURCE_IDS`](api/facade-representative-light-sources.md#representative_light_source_ids) | Runtime |
+| [`REPRESENTATIVE_LIGHT_SOURCE_SET_ID`](api/facade-representative-light-sources.md#representative_light_source_set_id) | Runtime |
+| [`REPRESENTATIVE_LIGHT_SOURCE_SET_VERSION`](api/facade-representative-light-sources.md#representative_light_source_set_version) | Runtime |
+| [`REPRESENTATIVE_LIGHT_SOURCE_WAVELENGTH_RANGE_NANOMETERS`](api/facade-representative-light-sources.md#representative_light_source_wavelength_range_nanometers) | Runtime |
+| [`RepresentativeLightSource`](api/facade-representative-light-sources.md#representativelightsource) | Type |
+| [`RepresentativeLightSourceBand`](api/facade-representative-light-sources.md#representativelightsourceband) | Type |
+| [`RepresentativeLightSourceId`](api/facade-representative-light-sources.md#representativelightsourceid) | Type |
+| [`RepresentativeLightSourceSet`](api/facade-representative-light-sources.md#representativelightsourceset) | Type |
+
 ## facade/scene-radiance.ts
 
 [Detailed contracts](api/facade-scene-radiance.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/facade/scene-radiance.ts)
@@ -1326,6 +1408,8 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`CHART_SIZE_DEFAULT_SURROUND_REFLECTANCE`](api/facade-scene-radiance.md#chart_size_default_surround_reflectance) | Runtime |
 | [`ChartSizeOption`](api/facade-scene-radiance.md#chartsizeoption) | Type |
 | [`createPlanarSceneRadianceProvider`](api/facade-scene-radiance.md#createplanarsceneradianceprovider) | Runtime |
+| [`ImagePlaneImage`](api/facade-scene-radiance.md#imageplaneimage) | Type |
+| [`ImagePlaneScene`](api/facade-scene-radiance.md#imageplanescene) | Type |
 | [`PHOTOPIC_MAXIMUM_LUMINOUS_EFFICACY_LM_PER_W`](api/facade-scene-radiance.md#photopic_maximum_luminous_efficacy_lm_per_w) | Runtime |
 | [`PlanarSceneRadianceProvider`](api/facade-scene-radiance.md#planarsceneradianceprovider) | Type |
 | [`resolveCaptureIlluminant`](api/facade-scene-radiance.md#resolvecaptureilluminant) | Runtime |
@@ -1552,6 +1636,14 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`CalculateProjectedMotionBlurInput`](api/motion-projected-motion.md#calculateprojectedmotionblurinput) | Type |
 | [`ProjectedMotionBlur`](api/motion-projected-motion.md#projectedmotionblur) | Type |
 
+## motion/subject-motion.ts
+
+[Detailed contracts](api/motion-subject-motion.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/motion/subject-motion.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`SimulateCaptureSubjectMotion`](api/motion-subject-motion.md#simulatecapturesubjectmotion) | Type |
+
 ## motion/temporal-exposure-sum.ts
 
 [Detailed contracts](api/motion-temporal-exposure-sum.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/motion/temporal-exposure-sum.ts)
@@ -1583,6 +1675,16 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`VIDEO_FRAME_SEQUENCE_VERSION`](api/motion-video-sequence.md#video_frame_sequence_version) | Runtime |
 | [`VideoFrameSequence`](api/motion-video-sequence.md#videoframesequence) | Type |
 
+## optics/aperture-diameter.ts
+
+[Detailed contracts](api/optics-aperture-diameter.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/optics/aperture-diameter.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`ApertureDiameter`](api/optics-aperture-diameter.md#aperturediameter) | Type |
+| [`calculateApertureDiameter`](api/optics-aperture-diameter.md#calculateaperturediameter) | Runtime |
+| [`CalculateApertureDiameterInput`](api/optics-aperture-diameter.md#calculateaperturediameterinput) | Type |
+
 ## optics/aperture.ts
 
 [Detailed contracts](api/optics-aperture.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/optics/aperture.ts)
@@ -1687,6 +1789,25 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`DefocusCircle`](api/optics-depth-of-field.md#defocuscircle) | Type |
 | [`DepthOfField`](api/optics-depth-of-field.md#depthoffield) | Type |
 
+## optics/detail-limit.ts
+
+[Detailed contracts](api/optics-detail-limit.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/optics/detail-limit.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`calculateDetailLimit`](api/optics-detail-limit.md#calculatedetaillimit) | Runtime |
+| [`CalculateDetailLimitInput`](api/optics-detail-limit.md#calculatedetaillimitinput) | Type |
+| [`DETAIL_LIMIT_LIMITS`](api/optics-detail-limit.md#detail_limit_limits) | Runtime |
+| [`DetailLimit`](api/optics-detail-limit.md#detaillimit) | Type |
+| [`DetailLimitBasis`](api/optics-detail-limit.md#detaillimitbasis) | Type |
+| [`DetailLimitCatalogueLens`](api/optics-detail-limit.md#detaillimitcataloguelens) | Type |
+| [`DetailLimitedBy`](api/optics-detail-limit.md#detaillimitedby) | Type |
+| [`DetailLimitIdealLens`](api/optics-detail-limit.md#detaillimitideallens) | Type |
+| [`DetailLimitingFactor`](api/optics-detail-limit.md#detaillimitingfactor) | Type |
+| [`DetailLimitOptics`](api/optics-detail-limit.md#detaillimitoptics) | Type |
+| [`DetailLimitSampling`](api/optics-detail-limit.md#detaillimitsampling) | Type |
+| [`DetailLimitSystem`](api/optics-detail-limit.md#detaillimitsystem) | Type |
+
 ## optics/diffraction-psf-profile.ts
 
 [Detailed contracts](api/optics-diffraction-psf-profile.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/optics/diffraction-psf-profile.ts)
@@ -1761,6 +1882,17 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`resolveFrontOfLensFilterTransmission`](api/optics-front-of-lens-filter.md#resolvefrontoflensfiltertransmission) | Runtime |
 | [`ResolveFrontOfLensFilterTransmissionInput`](api/optics-front-of-lens-filter.md#resolvefrontoflensfiltertransmissioninput) | Type |
 
+## optics/generic-lens-lateral-color.ts
+
+[Detailed contracts](api/optics-generic-lens-lateral-color.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/optics/generic-lens-lateral-color.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`calculateLateralColorFringe`](api/optics-generic-lens-lateral-color.md#calculatelateralcolorfringe) | Runtime |
+| [`CalculateLateralColorFringeInput`](api/optics-generic-lens-lateral-color.md#calculatelateralcolorfringeinput) | Type |
+| [`LateralColorDisplacement`](api/optics-generic-lens-lateral-color.md#lateralcolordisplacement) | Type |
+| [`LateralColorFringe`](api/optics-generic-lens-lateral-color.md#lateralcolorfringe) | Type |
+
 ## optics/generic-nd-filter-presets.ts
 
 [Detailed contracts](api/optics-generic-nd-filter-presets.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/optics/generic-nd-filter-presets.ts)
@@ -2117,6 +2249,16 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`CaptureSdrResult`](api/output-capture-sdr.md#capturesdrresult) | Type |
 | [`parseCaptureSdrInput`](api/output-capture-sdr.md#parsecapturesdrinput) | Runtime |
 
+## output/crop-to-match-focal-length.ts
+
+[Detailed contracts](api/output-crop-to-match-focal-length.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/output/crop-to-match-focal-length.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`calculateCropToMatchFocalLength`](api/output-crop-to-match-focal-length.md#calculatecroptomatchfocallength) | Runtime |
+| [`CalculateCropToMatchFocalLengthInput`](api/output-crop-to-match-focal-length.md#calculatecroptomatchfocallengthinput) | Type |
+| [`CropToMatchFocalLength`](api/output-crop-to-match-focal-length.md#croptomatchfocallength) | Type |
+
 ## output/crop.ts
 
 [Detailed contracts](api/output-crop.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/output/crop.ts)
@@ -2133,6 +2275,7 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 
 | Export | Kind |
 | --- | --- |
+| [`ChannelDispersion`](api/output-developed-lens-corrections.md#channeldispersion) | Type |
 | [`GENERIC_LENS_CORRECTION_CHANNEL_WAVELENGTHS_NM`](api/output-developed-lens-corrections.md#generic_lens_correction_channel_wavelengths_nm) | Runtime |
 
 ## output/generic-lens-corrections.ts
@@ -2141,6 +2284,8 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 
 | Export | Kind |
 | --- | --- |
+| [`calculateChannelEffectiveDispersion`](api/output-generic-lens-corrections.md#calculatechanneleffectivedispersion) | Runtime |
+| [`CalculateChannelEffectiveDispersionInput`](api/output-generic-lens-corrections.md#calculatechanneleffectivedispersioninput) | Type |
 | [`createGenericLensCorrectionProfile`](api/output-generic-lens-corrections.md#creategenericlenscorrectionprofile) | Runtime |
 | [`CreateGenericLensCorrectionProfileInput`](api/output-generic-lens-corrections.md#creategenericlenscorrectionprofileinput) | Type |
 
@@ -2286,7 +2431,9 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`calculatePrintPlan`](api/output-print-plan.md#calculateprintplan) | Runtime |
 | [`calculatePrintSizeLimit`](api/output-print-plan.md#calculateprintsizelimit) | Runtime |
 | [`parsePrintPlanInput`](api/output-print-plan.md#parseprintplaninput) | Runtime |
+| [`PrintContainLayout`](api/output-print-plan.md#printcontainlayout) | Type |
 | [`PrintedImageSize`](api/output-print-plan.md#printedimagesize) | Type |
+| [`PrintFit`](api/output-print-plan.md#printfit) | Type |
 | [`PrintLength`](api/output-print-plan.md#printlength) | Type |
 | [`PrintNativeSource`](api/output-print-plan.md#printnativesource) | Type |
 | [`PrintPlan`](api/output-print-plan.md#printplan) | Type |
@@ -2316,6 +2463,20 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`PrintRegionRaster`](api/output-print-region-statistics.md#printregionraster) | Type |
 | [`PrintRegionStatisticsAssessment`](api/output-print-region-statistics.md#printregionstatisticsassessment) | Type |
 
+## output/print-size-blur-noise.ts
+
+[Detailed contracts](api/output-print-size-blur-noise.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/output/print-size-blur-noise.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`calculatePrintSizeLimitWithBlurAndNoise`](api/output-print-size-blur-noise.md#calculateprintsizelimitwithblurandnoise) | Runtime |
+| [`PrintBlurInput`](api/output-print-size-blur-noise.md#printblurinput) | Type |
+| [`PrintImageMm`](api/output-print-size-blur-noise.md#printimagemm) | Type |
+| [`PrintNoiseInput`](api/output-print-size-blur-noise.md#printnoiseinput) | Type |
+| [`PrintSharpCleanCriterion`](api/output-print-size-blur-noise.md#printsharpcleancriterion) | Type |
+| [`PrintSizeLimitWithBlurAndNoise`](api/output-print-size-blur-noise.md#printsizelimitwithblurandnoise) | Type |
+| [`PrintSizeLimitWithBlurAndNoiseInput`](api/output-print-size-blur-noise.md#printsizelimitwithblurandnoiseinput) | Type |
+
 ## output/sdr-rendering.ts
 
 [Detailed contracts](api/output-sdr-rendering.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/output/sdr-rendering.ts)
@@ -3124,6 +3285,16 @@ Start here to find a function by task. [Using Photivra from an agent](AGENT_GUID
 | [`CalculateSceneSensorEqeTemporalExposureInput`](api/sensor-scene-eqe-temporal-exposure.md#calculatescenesensoreqetemporalexposureinput) | Type |
 | [`SceneSensorEqeTemporalExposure`](api/sensor-scene-eqe-temporal-exposure.md#scenesensoreqetemporalexposure) | Type |
 
+## sensor/sensor-characteristics.ts
+
+[Detailed contracts](api/sensor-sensor-characteristics.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/sensor/sensor-characteristics.ts)
+
+| Export | Kind |
+| --- | --- |
+| [`SimulateCaptureNoiseComponents`](api/sensor-sensor-characteristics.md#simulatecapturenoisecomponents) | Type |
+| [`SimulateCaptureSensorCharacteristics`](api/sensor-sensor-characteristics.md#simulatecapturesensorcharacteristics) | Type |
+| [`SimulateCaptureSensorReport`](api/sensor-sensor-characteristics.md#simulatecapturesensorreport) | Type |
+
 ## sensor/sensor-geometry.ts
 
 [Detailed contracts](api/sensor-sensor-geometry.md) · [Source](https://github.com/Photivra/photivra/blob/main/src/sensor/sensor-geometry.ts)

package/docs/QUICK_START.md

@@ -48,6 +48,7 @@ the example above is [simulate-capture.mjs](examples/simulate-capture.mjs).
 | `raw` | The packed native RAW: codes, black levels, saturation flags and per-phase white levels |
 | `plan` | The native RAW plan the engine executed |
 | `request` | The complete underlying request: `environmentRaw` (the native environment RAW input), `siteInput(index)` (rebuilds the physical input of any sensor site), `development` (the RAW development input) and `whiteBalanceState` |
+| `sensor` | 2.20 (#555, #535): the sensor characteristics used (pitch, peak QE, full well, read noise of each conversion gain and the dual-gain switch ISO, readout time, ADC bit depth, fixed-pattern noise), the calculated dynamic range (`dynamicRangeStops`, and per ISO setting) and, on exact requests, the mid-gray noise figure (`midGrey`); see [Sensor characteristics](#sensor-characteristics-555) |
 | `exposure` | Mode, resolved settings, EV100, `isoControl` (`"manual"` or `"automatic"`) and, with `iso: "auto"`, `autoIso` (how the ISO was chosen and what limited it), metered scene luminance, the deviation from the standard exposure in stops (`standardExposureDeviationStops`), the illuminance at which the settings give the standard exposure (`standardExposureIlluminanceLux`), from 2.14 the deviation from the standard exposure of an 18 % grey card under the scene's illuminance (`greyCardDeviationStops`, incident metering) and the exposure-mode resolver's full output |
 | `scene` | Chart parameters, illuminant, distance, framed size and the scene's SHA-256 digest (it covers caller illuminant and reflectance spectra; see `sourceSha256`) |
 | `diagnostics` | Radiance query count, highlight and rendering counters, per-stage timings (`timingsMs`) and, from 2.1, the opt-ins that ran (`options`); see [Cost of each option](#cost-of-each-option) |
@@ -87,6 +88,7 @@ modelling choices (such as "no lens PSF") as `kind: "model"`.
 | `chartSize` | fill the frame | 2.3: `{ widthM, heightM?, surroundReflectance? }` places the chart at its physical size (see [Fixed-size chart](#fixed-size-chart-23)). |
 | `illuminant` | Planckian 6500 K | Also `"cie-a"`, `{ kind: "planckian", temperatureKelvin }`, `{ kind: "daylight", correlatedColorTemperatureKelvin, basis }` or `{ kind: "spectrum", spectrum }`. |
 | `illuminanceLux` | 21 481 (π·80 000/11.7) | See [Exposure](#exposure). |
+| `illumination` | off | 2.22 (#550): mixed lighting, two to eight sources (`{ illuminant, illuminanceLux }`) blended across the chart by a linear gradient, a radial falloff or regions, and point sources (`points`) with inverse-square falloff, instead of `illuminant` and `illuminanceLux`. The frame center's light sets the grey card and its strongest source the `"scene-illuminant"` white balance (see [Mixed lighting](https://github.com/Photivra/photivra/blob/main/docs/MIXED_ILLUMINATION.md)). |
 | `output.width`, `output.height` | 64 × 64 | Output pixels, 1–4094 each. The sensor has one extra site on each side for demosaicing (see `output.borderHandling`). |
 | `output.maximumPixels` | off | Opt-in large images (2.2): the most native sensor sites the capture may allocate, up to `NATIVE_RAW_LIMITS.ceilingPixels` (2^27). Sides may then reach 16 384 sites including the margin (see [Large images](#large-images)). |
 | `output.region` | whole frame | 2.3: `{ x, y, width, height }` renders that rectangle of the frame, byte-identical to the whole render (see [Region rendering](#region-rendering-23)). |
@@ -117,6 +119,7 @@ modelling choices (such as "no lens PSF") as `kind: "model"`.
 | `motion.angularVelocityRadPerSec` | still | `{ pitch?, yaw?, roll? }` in rad/s (see [Motion](#motion)). |
 | `motion.shutter` | `"global"` | Or `"rolling"`. |
 | `motion.rollingShutterSkewSeconds` | the body's readout skew | Rolling only. |
+| `motion.subject` | still subject | 2.22.0: `{ velocityMPerSec?: { x?, y? }, angularVelocityRadPerSec?, region?, fast? }`, a moving subject (see [Subject motion](#subject-motion)). |
 | `signal`, `onProgress` | none | An `AbortSignal` cancels the running task; `onProgress` reports `raw`, `white-balance`, `development`, `diffraction-correction` and `sharpening` (#571: output rows, with those options) and `jpeg` tiles. The last event of each stage has `completedTileCount === totalTileCount`. The capture yields to the host about every 8 ms with a `MessageChannel` message (else `setImmediate`, else `setTimeout`), so other queued tasks run in between: an abort sent from another task, such as a Web Worker `message` event, takes effect at the next yield. |
 
 Unknown fields are rejected, so a typo never silently falls back to a default.
@@ -206,11 +209,13 @@ and every number is a labelled approximation.
   for the macro); an f-number or distance outside the lens's range is refused.
 - **Its character is rendered:** a field- and wavelength-dependent PSF (diffraction with the lens's Seidel aberrations, axial and
   lateral colour) through the environment PSF quadrature, its radial distortion, its vignetting and, for the fisheyes, the
-  equisolid projection (beyond 90° there is no scene, so the 8 mm's circle is black outside). Flare, focus breathing and the bokeh
-  shape are reported in the assumption `lens.catalogue.character`, not rendered.
+  equisolid projection (beyond 90° there is no scene, so the 8 mm's circle is black outside). Flare and focus breathing are
+  reported in the assumption `lens.catalogue.character`, not rendered.
 - **Professional lenses are better** where the owner's table says so: sharper centres and corners, less coma, lateral colour,
   distortion and vignetting, better close focus and focus consistency. The measurements are in the catalogue page.
-- **Combinations:** `lens.defocus` convolves the disc into the lens's PSF (a combined kernel up to 16 sites in radius);
+- **Combinations:** `lens.defocus` convolves the lens's own bokeh kernel (#567: its blades, its W040 and, on the fast wides
+  and normals, a cat's eye, which is lens.catalogue's exact method: on when the request resolves to exact (`fast: false`, the
+  default for DNG, JPEG and PNG), off on fast requests, since it would slow the fast method 2–3.5×; [Bokeh](https://github.com/Photivra/photivra/blob/main/docs/LENS_CATALOGUE.md#bokeh-567)) into the lens's PSF (a combined kernel up to 16 sites in radius);
   `lens.focusScatter: { seed, shotIndex? }` moves the focus by a seeded autofocus error (`simulateGenericLensFocusError`), off
   by default. `prime`, `focalLengthMm`, `projection`, `distortion`, `vignetting`, `psf`, `diffraction` and `pupilSampling` are
   set by the lens and refused with it. The display view renders `lens.catalogue` since #569, with the PSF taken per field zone
@@ -460,6 +465,96 @@ large-pixel sensor may therefore saturate earlier, and a real small-pixel sensor
 given a higher base ISO. When the pitch is not 6 µm, the assumption `sensor.isoAreaNormalization`
 records the area ratio and this approximation.
 
+### Sensor characteristics (#555)
+
+Each characteristic of the body's sensor can be set on its own under `sensor`. All are off by
+default: a request that sets none is byte-identical to 2.19.0, and every value set is listed in the
+assumption `sensor.characteristics`. The figures under the result's `sensor` are calculated from
+them; they are results, not settings.
+
+```ts
+const r = await simulateCapture({ scene: { preset: "uniform" }, sensor: {
+  pixelPitchMicrometers: 4,
+  peakQuantumEfficiency: 0.8,                       // green EQE at 555 nm, 0.05–0.9 (default 0.5)
+  fullWell: { electrons: 50_000, link: "none" },    // or linked to pixel area (the default)
+  readNoise: { lowGainElectrons: 3, highGainElectrons: 1.2, highGainFromIso: 640 },
+  readoutSeconds: 0.012,                            // rolling-shutter skew
+  adcBitDepth: 16,                                  // 12, 14 or 16
+  fixedPatternNoise: true                           // the body's synthetic pattern (advanced)
+}, fast: false });                                  // fast: false computes the mid-gray noise figure
+r.sensor.dynamicRangeStops; r.sensor.midGrey?.snrDecibels;
+```
+
+| Option | Range | Default | Effect |
+| --- | --- | --- | --- |
+| `peakQuantumEfficiency` | 0.05–0.9 | 0.5 | Multiplies every channel's EQE curve by value / 0.5: the curves keep their shape and the colour matrix, and the collected charge scales in proportion. 0.9 keeps the blue channel's peak below 1. |
+| `fullWell` | 100–1e10 e⁻ at the pitch | the body's base-ISO saturation at 6 µm, × pitch²/36 µm² | The charge at the RAW white level at base ISO (the saturation capacity of EMVA 1288 Release 4.0). `link: "pixel-area"` (default) scales `electrons`, the full well at `referencePixelPitchMicrometers` (default 6), by (pitch / reference)²; `link: "none"` uses it at any pitch. |
+| `readNoise` | 0–100 e⁻; switch ISO 100–1e7 | the body's (tiers: 2/1.1, 3/1.4 and 6/2.5 e⁻, switch at ISO 800) | Read noise of the low and the high conversion gain, and `highGainFromIso`, the ISO from which the high gain is used. A switch above the body's top ISO keeps the low gain throughout. |
+| `readoutSeconds` | 1e-6–1 s | the body's (8, 15, 30 ms) | The rolling shutter's top-to-bottom skew (`motion.shutter: "rolling"`; `motion.rollingShutterSkewSeconds` still overrides it). |
+| `adcBitDepth` | 12, 14, 16 | the body's (consumer 12, others 14) | The black level scales by 2^Δbits (1 024 at 14 bits → 4 096 at 16), the saturation code is 2^bits − 1 and the conversion gain follows, so the same charge reaches the same fraction of the code range. A 16-bit RAW writes a 16-bit DNG with white level 65 535. |
+| `fixedPatternNoise` | `true`/`false` | `false` | The body's synthetic fixed-pattern profile (PRNU, DSNU, hot pixels, row and column offsets), the same pattern in every capture. Not available in `simulateDisplayView`, which refuses it. |
+
+How the full well and the ISO rating interact (an approximation, recorded in the assumption): the
+facade keeps each ISO setting's readout regime, so the full well is reached at the white level of
+base ISO and every regime's conversion gain and pre-ADC saturation scale with it (`chargeScale`).
+The output per unit focal-plane exposure H then changes by 2^`sensitivityOffsetStops` =
+QE scale × (pixel area / 36 µm²) × (body full well / full well): the body's rating S = 10/H (CIPA
+DC-004-2020 §3.2) still holds only when that is 1, as it is for a linked full well and the default
+QE. A higher QE makes the same exposure brighter; a larger unlinked full well makes it darker and
+gives more highlight headroom. The high conversion gain's smaller charge storage is not modelled
+when the switch ISO is lowered. The assumption notes a full well outside 200–10 000 e⁻ per µm² of
+pixel area as unusual for the pitch; that is a design range around the tiers' 556–1 667 e⁻/µm² and
+published values such as about 4 000 e⁻/µm² at 2 µm and 1 400 e⁻/µm² at 5.2 µm (Farrell, Xiao &
+Kavusi, *Proc. SPIE* 6069, 2006, Table 1), not a published bound.
+
+**Dynamic range** (`sensor.dynamicRangeStops` at the capture's ISO, `sensor.dynamicRangeByIso` for
+every ISO setting of the body): engineering dynamic range log₂(S_sat / σ_floor). S_sat is the charge
+at the RAW white level (the full well over the analog gain, limited by the charge capacity and the
+ADC range) and σ_floor = √(σ_read² + σ_q²), the temporal dark noise of EMVA 1288 Release 4.0 without
+dark current, with σ_q the ADC quantization (1/12 code², plus 1/12 code² of rounding after a digital
+gain) in electrons. With no read noise the range is limited by the ADC alone: log₂((white − black)·√12).
+The Professional tier gives 14.7 stops at ISO 100, 12.7 at ISO 800 (high gain) and 9.7 at ISO 6400;
+the Consumer tier 11.7, 10.0 and 7.0.
+
+**Noise figure** (#535, `sensor.midGrey`): computed only when the request resolves to exact (`fast:
+false`, the default for DNG, JPEG and PNG exports; about 0.3 ms); a fast request (the sRGB default)
+omits it. The expected signal-to-noise ratio of an 18 % Lambertian
+gray patch under the request's illuminant and illuminance, at the capture's exposure, ISO and
+sensor, from the engine's own noise model (a model figure, not a measurement). It is the green
+channel next to the optical axis (no vignetting, PSF or motion). `signalElectrons` S is the patch's
+expected charge; `noiseElectrons` splits the noise into photon shot √S, read, dark-current shot
+√(D·t) with D = 1 e⁻/s, ADC quantization and, with `fixedPatternNoise`, the fixed pattern
+√((PRNU·S)² + (DSNU·D·t)² + row² + column²) (hot pixels excluded; a spatial noise, the same in every
+capture), added in quadrature as `total`. `snr` = S / total and `snrDecibels` = 20·log₁₀(snr).
+`clipped` is true when the patch reaches the white level, where the figure no longer describes
+the image. With the defaults (Professional, f/8, 1/125 s, ISO 100, 21 481 lux) S ≈ 7 842 e⁻ and the
+SNR is 88.5 (38.9 dB); at ISO 6400 with 1/64 of the light, S ≈ 123 e⁻ and the SNR is 11.0 (20.8 dB):
+the photon shot noise grows as √S, so less light means more noise whatever the ISO. The display view
+reports the same `sensor` record as its capture.
+
+### Sensor profiles (#554)
+
+`sensor.profile` takes one of eight representative sensor profile records whose values come from
+published specifications (`SENSOR_PROFILES`, or `resolveSensorProfile(id)`; unnamed, by format,
+resolution, architecture and era), checked strictly, so a modified copy also works. It
+replaces the body's ISO range, readout regimes (full well, read noise of each conversion gain, the
+dual-gain switch and the high gain's storage, ADC bit depth), readout time and fixed-pattern noise,
+and sets the default pitch and peak QE; the characteristics above still override it one at a time.
+
+```ts
+import { resolveSensorProfile, simulateCapture } from "@photivra/engine";
+const phone = await simulateCapture({ scene: { preset: "uniform" }, sensor: { profile: resolveSensorProfile("phone-50mp-stacked") } });
+phone.sensor.fullWellElectrons;   // 8 600 e⁻ at 1.197 µm
+```
+
+Each profile's base ISO is re-rated from its full well, QE and pixel area, so the same ISO reaches
+the RAW white at the same exposure on every profile (the assumption `sensor.profile` records the
+values and the rounding). The phone profile takes the catalogue's three phone lenses
+(`lens: { catalogue: "pv-24-1.8-phone" }`), and they need it. With a profile, a catalogue lens is framed on
+the profile's real sensor (the largest centred region of the output's aspect; assumption `sensor.profileView`), so it
+shows its real field of view. Values, sources, the framing and the ISO rating:
+[SENSOR_PROFILES.md](https://github.com/Photivra/photivra/blob/main/docs/SENSOR_PROFILES.md).
+
 ## Exposure
 
 The facade meters the scene like a reflected-light meter:
@@ -1093,6 +1188,18 @@ The optics options feed only what the environment site contract accepts:
     scene; a test checks it to 1e-12 per site. With camera rotation, a projection or distortion, or
     vignetting, the per-tap quadrature runs instead (much slower). `request.diffraction` holds the profile,
     the equivalent `sampled-local` PSF and which execution ran.
+  - Ties on chart boundaries (2.20.0, #565): the per-tap quadrature reads each tap's scene point at its site-lattice point, as
+    the object-space convolution, the out-of-focus capture and the display view do, so a tap exactly on a chart boundary (a
+    Siemens star's spokes through lattice points) resolves to the same material on every path. With camera rotation under
+    `motion.shutter: "rolling"` every row has its own instants, so the lattice is read once per instant; there reading the
+    lattice is `lens.diffraction`'s exact method and keeping each tap's own point its fast method; the lattice costs about
+    1.2× the time (dead leaves 48 × 32 at f/8: 4.0–4.1 s against 4.8–5.0 s; a Siemens star 32 × 24 at f/16: 6.8 s against
+    8.1–8.2 s; November 9, 2026, Apple M5 Pro, Node 24.19.0). The format default decides (2.20.0): fast for sRGB samples, exact for
+    DNG, JPEG and PNG; `lens.diffraction: { kind, fast }` or the top-level `fast` wins, and the fast method reports
+    `diagnostics.fast.applied["lens.diffraction"]: true` and the assumption `fast.lens.diffraction`. The two readings differ
+    only at such ties. Region renders joined into one frame (`serializeSimulatedCaptureDngFromParts`,
+    `simulateCaptureFromParts`) match the whole-frame render only if every part resolves `fast` the same way: give the parts
+    and the whole request the same `fast` (a part rendered fast is refused by an exact join).
   - The convolution runs in 32-row bands and computes only each band's own values, not the 2R rows and
     columns of padding around it (#419; the values are bit-identical to the full-grid convolution's). On a
     function scene with the Quality options at 1 µm and f/16 (R 32), 96 × 72, `diagnostics.timingsMs.diffraction`
@@ -1423,9 +1530,9 @@ lens: { focalLengthMm: 50, fNumber: 4, focusDistanceM: 1.4, defocus: { model: "g
   combined with `lens.diffraction` (every zone would need its own combined kernel per node). Above a kernel radius of 64
   sites it is refused: #564's run convolution takes one kernel per request, and extending it to one kernel per zone is left
   for later. `simulateDisplayView` and `prepareDisplayView` refuse it; they render `blades` and `sphericalAberration`.
-- **With `lens.catalogue` (#549)** the three options are refused by name. The catalogue lens folds a plain disc into its
-  own PSF, so they would otherwise be dropped. Feeding a catalogue lens's spherical aberration and character into the
-  bokeh kernel is a follow-up ([#567](https://github.com/Photivra/photivra/issues/567)), not a 2.17.0 feature.
+- **With `lens.catalogue` (#549)** the three options are refused by name: since 2.20.0 (#567) the catalogue lens sets
+  all three itself (its blades, its own W040 and, on the fast wides and normals, a cat's eye) and folds that kernel into
+  its PSF ([Lens catalogue, Bokeh](https://github.com/Photivra/photivra/blob/main/docs/LENS_CATALOGUE.md#bokeh-567)).
 - **Sampling.** Without spherical aberration each site's weight is the exact area of the projected open pupil (a convex
   polygon; circles and blade arcs are 1024-gons scaled to their true area, within 5e-6 of the radius of the true curve)
   inside the site's cell, divided by its area (`"exact-polygon-cell-area"`). With it the pupil is sampled on a square grid
@@ -1607,6 +1714,48 @@ const pan = await simulateCapture({
 console.log(pan.assumptions.find((a) => a.id === "sensor.shutter")?.value, pan.exposure.settings.shutterSeconds);
 ```
 
+## Subject motion
+
+`motion.subject` (2.22.0, #551) moves the subject on the scene plane during the exposure: the whole scene, or one
+rectangle of it (`region: { centerXM, centerYM, widthM, heightM }` in metres at rest) over a still background.
+
+- `velocityMPerSec: { x, y }` is a translation in m/s on the plane (+x right, +y up as seen from the camera).
+  `angularVelocityRadPerSec` adds a rotation about an axis parallel to the optical axis, counter-clockwise as seen from
+  the camera: the optical axis for the whole scene, the region's center for a region.
+- The model is rigid motion of a planar layer. At time t from the first opening (camera rotation's time reference), a
+  subject point at rest q is at R(ωt)(q − c) + c + v·t. A plane point shows the subject where one is there, else the
+  region's rest rectangle shows a neutral 18 % background (what the subject revealed), else the still scene. The background
+  is lit by the plane's irradiance at that point: the illuminant, or with `illumination` (#550) the blend and point sources there.
+- Every scene query reads the subject at its own time. The blur is therefore the same temporal midpoint quadrature as
+  camera rotation (`sensor.temporalSampleCount`, default 8 with a moving subject), and an edge streaks over
+  v·T·m on the sensor (m = v′/D, the thin-lens image distance over the subject distance). With few samples a long streak
+  shows separate copies; raise the count. A test checks the length within sampling error.
+- A rolling shutter skews a moving subject: each row's exposure window opens later, so it sees the subject later. A test
+  checks the skew against the site windows' start offsets.
+- Panning: a camera yaw of −v/D rad/s (the engine's rotation convention) follows a subject moving at v m/s in +x. The
+  subject stays sharp and the background streaks.
+- It combines with `lens.diffraction`, `lens.defocus` (global shutter; their site lattices are formed at each midpoint), the
+  lens projection, distortion and vignetting, and camera rotation. `lens.pupilSampling` is refused.
+- Display view: sideways motion under a global shutter only. It refuses a rotating subject and a rolling shutter with a
+  reason; `simulateCapture` renders both.
+- Fast method (2.20.0 convention): with the default count and a still camera, `fast` takes one midpoint per site of the
+  streak plus one when that is fewer than 8 (taps less than one site apart). Exact keeps 8, and an explicit
+  `sensor.temporalSampleCount` always wins. Fast is the default for sRGB samples and the display view, exact for DNG,
+  JPEG and PNG.
+- Off by default: a request without `motion.subject` is byte-identical to 2.20.0.
+
+```ts
+import { simulateCapture } from "@photivra/engine";
+
+// A subject 4 mm wide moving right at 0.2 m/s, with the camera panning to follow it.
+const pan = await simulateCapture({
+  scene: { preset: "bar-groups" }, subjectDistanceM: 2, lens: { focalLengthMm: 50 },
+  motion: { angularVelocityRadPerSec: { yaw: -0.1 }, subject: { velocityMPerSec: { x: 0.2 }, region: { centerXM: 0.002, centerYM: 0, widthM: 0.004, heightM: 0.004 } } },
+  output: { width: 32, height: 16 }
+});
+console.log(pan.assumptions.find((a) => a.id === "motion.subject")?.value);
+```
+
 ## Performance
 
 Almost all of the cost is engine time per sensor site; the facade itself adds little. Since 2.0, the
@@ -1947,6 +2096,64 @@ developed image in 64-bit floats (24 bytes per pixel, 549 MiB at 24 MP), held as
 sampled every 50 ms). The extra pass therefore costs about 5 s on one worker after the parts, against about 10 s to render
 the whole frame again on one worker.
 
+### Exposure build-up (#534)
+
+`simulateExposureBuildUp(options, { fractions })` renders fractions of one exposure as one accumulating process, the way a
+camera's live readout of a long exposure shows the light building up. Each fraction is read out and developed as its own
+photo, and the fraction at 1 is `simulateCapture(options)`, byte for byte (owner decision, 2026-11-06).
+
+- **Signal.** Each fraction fⱼ below 1 is a capture of the same request in manual mode at the whole exposure's resolved
+  f-number and ISO and the shutter fⱼ·t. So its expected signal at every site is integrated from the spectrum over the window
+  [0, fⱼ·t] by the capture itself. That includes camera rotation, `motion.subject` (#551), mixed lighting (#550, which does not
+  change over time) and, with a rolling shutter, each row's own window. No per-channel signal is precomputed (owner rule).
+- **Charge.** Photon and dark-charge arrivals are Poisson processes with any rate over time. Given a count n over [0, t], the
+  count over [0, s] is Binomial(n, Λ(s)/Λ(t)), with Λ the expected count (R. G. Gallager, *Discrete Stochastic Processes*,
+  chapter 2, sections 2.4 and 2.5, MIT OpenCourseWare 6.262, free). The whole exposure keeps its ordinary draws. Going down
+  the fractions, each site's photo and dark counts are split: N(fⱼ) ~ Binomial(N(fⱼ₊₁), λ(fⱼ)/λ(fⱼ₊₁)), with λ the site's
+  expected mean in each render (after PRNU and DSNU). As a result:
+  - each fraction's counts are Poisson with that fraction's own mean, which is the mean and variance of a capture at fⱼ·t;
+  - the counts never decrease from one fraction to the next;
+  - two fractions' counts covary by the earlier one's mean.
+
+  The binomial draws are exact: inversion, and Hörmann's BTRS rejection (`src/sensor/binomial-sample.ts`).
+- **Quadrature.** The windows are nested, so the true means never decrease. The temporal midpoint quadrature can still give an
+  earlier fraction a larger estimate than a later one at a site under motion. There the count is kept (probability 1), and the
+  `exposure.buildUp` assumption counts those sites (`nonMonotoneSites`). Raise `sensor.temporalSampleCount` to remove them.
+- **Sensor.** Fixed-pattern noise (PRNU, DSNU, hot pixels, offsets) belongs to the sensor and is the same in every fraction.
+  Each fraction's charge is clipped at the full well (`sensor.fullWell`), then read out once: its own read noise (the regime's
+  components; dual gain as the ISO selects), pre-ADC and ADC saturation, and quantization at the ADC bit depth (#555; a #554
+  sensor profile's readout feeds the same stage).
+- **Cost and settings.** One capture per fraction, plus about 64 bytes per native site for the chain. The request's `fast`
+  and the format default apply to every fraction, and the build-up adds no fast method: with `fast: false` (the calculator's
+  setting) every fraction is an exact capture. `"auto"` white balance is measured on each fraction, as its own photo.
+- **Limits.** On screen only: formats `"srgb-8"` and `"srgb-16"` (a fraction's JPEG, PNG or DNG is refused). 1 to 64
+  fractions, strictly increasing, above 0 and at most 1. Each fraction's shutter fⱼ·t must be one the body can set. A
+  fraction's realization depends on the whole list, because each step of the chain has its own seeded streams
+  (`EXPOSURE_BUILD_UP_STREAM_BASE`). The same request and list always give the same frames.
+- **Result.** One frame per fraction: `{ fraction, elapsedSeconds, result }`. Below 1, `result` is the fraction capture's
+  result (`image`, `raw`, `plan` and `request` at fⱼ·t), with the build-up's counts and the assumption `exposure.buildUp`.
+  Its `exposure` and `sensor` are the whole exposure's reports: the camera's settings and noise figure, not the elapsed part's.
+
+```ts
+import { simulateExposureBuildUp } from "@photivra/engine";
+
+const build = await simulateExposureBuildUp({ scene: { preset: "slanted-edge" }, exposure: { mode: "manual", shutterSeconds: 1 / 15, iso: 400 },
+  motion: { angularVelocityRadPerSec: { yaw: 0.2 } }, output: { width: 64, height: 48 } }, { fractions: [0.2, 0.4, 0.6, 0.8, 1] });
+for (const frame of build.frames) console.log(frame.fraction, frame.elapsedSeconds, frame.result.image.samples.length);
+```
+
+The tests are in `test/exposure-build-up.test.ts`:
+
+- The last fraction equals `simulateCapture` byte for byte: tabulated and lean paths, fixed pattern, dual gain, auto white
+  balance and Auto ISO, camera rotation, rolling shutter, a moving subject and mixed lighting.
+- Each fraction's mean and variance match a single capture at f·t. Under motion this is checked column by column, and the
+  fraction is shown to differ from the whole exposure scaled by f.
+- Without read noise the codes never decrease, and Cov(c₁, c₂) = Var(c₁).
+- Dark frames' read noise is independent between readouts.
+- A fraction past the full well clips.
+
+`test/binomial-sample.test.ts` checks the binomial draws with chi-square tests of the probability mass function.
+
 ### A Print JPEG written in strips
 
 At 1:1 (output size equal to the crop), a Print JPEG's rows can be coded on separate workers.