@photivra/engine 0.5.0 → 0.6.0

package/dist/sensor/spatial-sampling-quadrature.js

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: Apache-2.0
+import { approximationResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError, requirePositiveInteger } from "../core/validation.js";
+import { resolveAntiAliasingSpatialKernel } from "./optical-stack.js";
+import { resolveSensorSamplingAperture } from "./sampling-aperture.js";
+const MAX_SPATIAL_QUADRATURE_NODES = 100_000;
+function midpointCoordinate(index, count) {
+    return (index + 0.5) / count;
+}
+function insideImagingArea(pointMm, imagingArea) {
+    const halfWidth = imagingArea.widthMm / 2;
+    const halfHeight = imagingArea.heightMm / 2;
+    return (pointMm.x >= -halfWidth &&
+        pointMm.x <= halfWidth &&
+        pointMm.y >= -halfHeight &&
+        pointMm.y <= halfHeight);
+}
+/**
+ * Builds deterministic spatial quadrature nodes for one CFA/color-sampling site.
+ *
+ * The quadrature composes:
+ *
+ * 1. the resolved geometric sensitive aperture from the sampling-aperture
+ *    foundation; and
+ * 2. the resolved effective AA point-splitting kernel from the optical-stack
+ *    foundation.
+ *
+ * The first aperture integration uses a tensor-product uniform midpoint rule.
+ * For an AA component that moves optical energy by +delta on the sensor plane,
+ * a destination aperture point samples the pre-AA optical field at
+ * destination - delta. This inverse-source convention prevents applying the AA
+ * shift twice.
+ *
+ * The destination sensor site's CFA channel applies to every node. The
+ * pre-AA source coordinate is an optical-field location, not another CFA site;
+ * therefore shifted source coordinates never reassign the destination channel.
+ *
+ * Nodes whose pre-AA source coordinates fall outside the active imaging area
+ * are retained. They are neither clamped nor dropped/renormalized. A renderer
+ * or optical-field provider owns source-coverage policy.
+ *
+ * normalized weights approximate a spatial average. Square-micrometre measures
+ * approximate a geometric area integral. Neither includes radiometric
+ * throughput, QE, photon conversion, microlenses, diffusion/crosstalk, or
+ * temporal integration.
+ */
+export function calculateSensorSpatialSamplingQuadrature(input) {
+    requirePositiveInteger("spatialSampleCountX", input.spatialSampleCountX);
+    requirePositiveInteger("spatialSampleCountY", input.spatialSampleCountY);
+    const samplingAperture = resolveSensorSamplingAperture({
+        imagingArea: input.imagingArea,
+        nativeRaster: input.nativeRaster,
+        colorSamplingProfile: input.colorSamplingProfile,
+        colorSamplingBindingProfile: input.colorSamplingBindingProfile,
+        samplingApertureProfile: input.samplingApertureProfile,
+        site: input.site
+    });
+    const antiAliasing = resolveAntiAliasingSpatialKernel(input.opticalStackProfile);
+    const apertureNodeCount = input.spatialSampleCountX *
+        input.spatialSampleCountY;
+    if (!Number.isSafeInteger(apertureNodeCount)) {
+        throw new InvalidScientificInputError("spatialSampleCountX × spatialSampleCountY must be a safe integer.");
+    }
+    const totalNodeCount = apertureNodeCount *
+        antiAliasing.components.length;
+    if (!Number.isSafeInteger(totalNodeCount)) {
+        throw new InvalidScientificInputError("Spatial quadrature node count must be a safe integer.");
+    }
+    if (totalNodeCount >
+        MAX_SPATIAL_QUADRATURE_NODES) {
+        throw new InvalidScientificInputError("Spatial quadrature node count exceeds the per-site safety limit of " +
+            MAX_SPATIAL_QUADRATURE_NODES +
+            ". Increase fidelity by tiling or batching downstream work rather than allocating one oversized node set.");
+    }
+    const aperture = samplingAperture.geometricSensitiveAperture;
+    const normalizedApertureWeight = 1 / apertureNodeCount;
+    const apertureAreaMeasureSquareMicrometers = aperture.areaSquareMicrometers /
+        apertureNodeCount;
+    const apertureCenterMm = aperture.centerFromOpticalAxisMm;
+    const widthMm = aperture.widthMicrometers / 1000;
+    const heightMm = aperture.heightMicrometers / 1000;
+    const leftMm = apertureCenterMm.x - widthMm / 2;
+    const topMm = apertureCenterMm.y - heightMm / 2;
+    const nodes = [];
+    let outsideCount = 0;
+    antiAliasing.components.forEach((aaComponent, antiAliasingComponentIndex) => {
+        const aaOffsetMm = {
+            x: aaComponent.offsetMicrometers.x /
+                1000,
+            y: aaComponent.offsetMicrometers.y /
+                1000
+        };
+        for (let apertureSampleYIndex = 0; apertureSampleYIndex <
+            input.spatialSampleCountY; apertureSampleYIndex += 1) {
+            const yPhase = midpointCoordinate(apertureSampleYIndex, input.spatialSampleCountY);
+            const destinationY = topMm + yPhase * heightMm;
+            for (let apertureSampleXIndex = 0; apertureSampleXIndex <
+                input.spatialSampleCountX; apertureSampleXIndex += 1) {
+                const xPhase = midpointCoordinate(apertureSampleXIndex, input.spatialSampleCountX);
+                const destinationX = leftMm + xPhase * widthMm;
+                const destinationAperturePointMm = {
+                    x: destinationX,
+                    y: destinationY
+                };
+                const preAntiAliasingSourcePointMm = {
+                    x: destinationX -
+                        aaOffsetMm.x,
+                    y: destinationY -
+                        aaOffsetMm.y
+                };
+                const sourceInside = insideImagingArea(preAntiAliasingSourcePointMm, input.imagingArea);
+                if (!sourceInside) {
+                    outsideCount += 1;
+                }
+                const combinedNormalizedSpatialWeight = normalizedApertureWeight *
+                    aaComponent.normalizedWeight;
+                const combinedAreaMeasureSquareMicrometers = apertureAreaMeasureSquareMicrometers *
+                    aaComponent.normalizedWeight;
+                nodes.push({
+                    antiAliasingComponentIndex,
+                    apertureSampleXIndex,
+                    apertureSampleYIndex,
+                    destinationAperturePointMm,
+                    antiAliasingOffsetMicrometers: {
+                        ...aaComponent.offsetMicrometers
+                    },
+                    preAntiAliasingSourcePointMm,
+                    preAntiAliasingSourceInsideImagingArea: sourceInside,
+                    normalizedApertureWeight,
+                    normalizedAntiAliasingWeight: aaComponent.normalizedWeight,
+                    combinedNormalizedSpatialWeight,
+                    apertureAreaMeasureSquareMicrometers,
+                    combinedAreaMeasureSquareMicrometers
+                });
+            }
+        }
+    });
+    const normalizedSpatialWeightSum = nodes.reduce((sum, node) => sum +
+        node.combinedNormalizedSpatialWeight, 0);
+    const combinedAreaMeasureSumSquareMicrometers = nodes.reduce((sum, node) => sum +
+        node.combinedAreaMeasureSquareMicrometers, 0);
+    return approximationResult({
+        coordinateSystem: "native-sensor-physical",
+        site: {
+            ...samplingAperture.site
+        },
+        channelId: samplingAperture.channelId,
+        quadratureScheme: "tensor-product-uniform-midpoint",
+        outputMeaning: "pre-aa-optical-field-spatial-quadrature-nodes",
+        spatialSampleCountX: input.spatialSampleCountX,
+        spatialSampleCountY: input.spatialSampleCountY,
+        antiAliasingComponentCount: antiAliasing.components.length,
+        totalNodeCount,
+        geometricApertureAreaSquareMicrometers: aperture.areaSquareMicrometers,
+        normalizedSpatialWeightSum,
+        combinedAreaMeasureSumSquareMicrometers,
+        preAntiAliasingSourceOutsideImagingAreaNodeCount: outsideCount,
+        sourcePointRule: "pre-aa-source-equals-destination-minus-aa-offset",
+        destinationCfaChannelAppliesToAllNodes: true,
+        cfaReassignmentBySourceCoordinate: false,
+        sourceCoveragePolicy: "not-applied",
+        nodes,
+        opticalFieldValuesIncluded: false,
+        radianceIncluded: false,
+        photonsIncluded: false,
+        electronsIncluded: false,
+        spectralResponseIncluded: false,
+        quantumEfficiencyIncluded: false,
+        opticalThroughputIncluded: false,
+        microlensResponseIncluded: false,
+        chargeDiffusionIncluded: false,
+        electricalCrosstalkIncluded: false,
+        temporalIntegrationIncluded: false,
+        rawSampleValueIncluded: false,
+        reconstructedPixelValueIncluded: false,
+        geometricAreaMeasureIsRadiometricCollectionArea: false,
+        componentEvidence: {
+            samplingApertureProfile: samplingAperture.provenance.profile,
+            samplingApertureLattice: samplingAperture.provenance.lattice,
+            geometricSensitiveAperture: samplingAperture.provenance.aperture,
+            opticalStackProfile: antiAliasing.provenance.profile,
+            antiAliasingResponse: antiAliasing.provenance
+                .antiAliasingResponse
+        }
+    }, "sensor-spatial-sampling-quadrature", "1.0.0", [
+        "Spatial aperture integration uses a deterministic tensor-product uniform midpoint rule.",
+        "The destination sensor site's semantic CFA/color channel applies to every quadrature node; pre-AA source coordinates never reassign the destination channel.",
+        "AA point-splitting is inverse-sampled: a +delta output displacement reads the pre-AA optical field at destination - delta.",
+        "AA component weights and aperture midpoint weights are dimensionless normalized spatial-average weights.",
+        "Square-micrometre measures are geometric integration measures only and are not effective radiometric collection area, throughput, QE, or photon count.",
+        "Pre-AA source points may leave the active physical imaging area and are not clamped, dropped, or renormalized.",
+        "The AA kernel remains the optical-stack foundation's field/wavelength/polarization-invariant approximation where applicable.",
+        "Microlens spatial response, charge diffusion, electrical/optical crosstalk, spectral response, radiometry, temporal integration, RAW sample generation, and reconstruction remain separate future work.",
+        "No geometry-only spatial quadrature error estimate is reported because downstream optical-field spatial frequency/content determines integration error."
+    ]);
+}
+//# sourceMappingURL=spatial-sampling-quadrature.js.map

package/dist/sensor/spatial-sampling-quadrature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-sampling-quadrature.js","sourceRoot":"","sources":["../../src/sensor/spatial-sampling-quadrature.ts"],"names":[],"mappings":"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"}

package/docs/ARCHITECTURE.md

@@ -45,6 +45,18 @@ Equivalent focal length is also layered on top of physical capture geometry rath
 
 Sensor architecture is a separate descriptive layer. Illumination (FSI/BSI), integration/stacking, readout capabilities, and color-sampling family are independent evidence-backed facts. Their presence alone has no image-quality effect in the engine. Evidence origin is modeled independently from reuse rights, scalar facts may cite multiple evidence records, and multi-valued capabilities carry evidence per value. Omitted facts remain unknown rather than being inferred. Capture-mode semantics, readout timing, reconstruction, and calibrated radiometry consume these facts only through later explicit models.
 
+Exact color-sampling topology is a separate layer again. `SensorColorSamplingProfile` can describe monochrome or an arbitrary periodic mosaic on an abstract native sensor sampling-site lattice, while layered color uses a separate unresolved spatial reference and remains structural-only until per-layer spatial sampling is modeled. This lattice is intentionally not `NativeImageRaster`; a future binding must establish how capture-mode effective samples relate to color-sampling sites. Active crop/orientation/output transforms therefore cannot reset periodic CFA phase, and architecture-family metadata cannot synthesize an exact tile.
+
+That binding is now explicit through the native-effective-raster/color-site foundation. One evidence-backed profile ties one exact canonical native effective raster to regular sensor-anchored color-site blocks; a second resolver composes that relationship with a selected capture mode. Grouped modes require separately evidenced full-frame grouping phase, use absolute full-frame mode indices, and return compact pre-reconstruction source rectangles plus channel-site counts. Matching dimensions alone never create a binding. Pixel-shift metadata does not re-phase the CFA because the sensor/filter structure moves together; its optical-registration effect remains a later spatial-sampling concern. Declared-effective capture modes and unresolved layered layouts fail closed rather than receiving inferred mappings.
+
+Sensor optical-stack metadata is a separate upstream layer. `SensorOpticalStackProfile` records ordered physical component roles and microlens presence independently from the effective anti-aliasing spatial response. Unknown AA response, documented absence/cancellation, unresolved presence, and an explicit normalized point-splitting kernel remain distinct. The first kernel is native-sensor-physical, field/wavelength/polarization-invariant, and spatial-only; it does not include throughput, spectral filtering, cover-glass refraction, microlens collection, or whole-stack PSF composition. This prevents OLPF presence from becoming a universal Gaussian/four-ray blur and prevents descriptive filter/microlens metadata from silently changing image formation.
+
+Physical sampling aperture is a separate downstream prerequisite for CFA/site sampling. `SensorSamplingApertureProfile` explicitly registers the regular color-site center lattice in native sensor physical coordinates and can declare the first geometric sensitive-region approximation as a uniform rectangle. Site pitch/origin is never derived from `NativeImageRaster`, and aperture dimensions/offset are never inferred from pitch or a scalar fill fraction. The derived geometric sensitive-area fraction is diagnostic only. AA redistribution, microlenses, charge diffusion/crosstalk, spectral response, QE, optical throughput, radiometric collection area, and physical photodiode geometry remain separate models so spatial sampling can later compose them deliberately rather than double-count them.
+
+The spatial-quadrature foundation now performs that first explicit composition of AA redistribution and geometric aperture support. It inverse-samples the pre-AA optical field, keeps the destination CFA channel authoritative, returns both normalized-average and geometric-area measures, and preserves off-imaging-area optical support without clamping. It still evaluates no optical/radiometric values and remains separate from temporal quadrature, microlens response, diffusion/crosstalk, RAW generation, and reconstruction.
+
+The spatial-sample reducer now evaluates those quadrature weights against explicitly supplied nonnegative linear values. It supports either a dimensionless relative irradiance proxy or physical sensor-plane irradiance in W/m², matches values by node identity rather than position, and preserves both average and area-integral semantics. CFA channel labeling remains metadata until a later spectral response model; temporal exposure, photons/electrons, noise, ADC and RAW/reconstruction remain downstream.
+
 
 ## Image-formation ownership and ordering
 
@@ -118,6 +130,11 @@ Compatibility boundaries remain explicit:
 The POC still does **not** consume:
 
 - `SensorArchitectureProfile`;
+- `SensorColorSamplingProfile`;
+- `NativeEffectiveRasterColorSamplingBindingProfile`;
+- `SensorOpticalStackProfile`;
+- `SensorSamplingApertureProfile`;
+- `CaptureModeProfile`;
 - `RadiometryReadinessProfile` or calibrated photon/noise output.
 
 That separation is deliberate. Further foundation APIs should remain independently testable and only enter the POC through explicit contract/version changes and migration review.

package/docs/AUTOMATION_COORDINATION.md

@@ -0,0 +1,188 @@
+# Public-engine automation coordination
+
+This document coordinates the two recurring automation lanes that work only in the public
+`Photivra/photivra` repository. It is process guidance, not a scientific roadmap. Open issues and
+the repository's scientific/API documentation remain authoritative for product and model semantics.
+
+## Lanes
+
+- **Engine Science** (`engine-science`) owns scientific/foundational roadmap work.
+- **Export & Performance** (`export-performance`) owns `SimulatedCapture`, TIFF/DNG export,
+  measured performance work, and CI-efficiency work.
+
+Each roadmap issue should contain a short **Automation coordination** block identifying its owner
+lane, dependencies, and cross-lane handoff. That block coordinates work; it does not override the
+issue's scientific acceptance criteria.
+
+## Control plane
+
+Automation coordination state lives on the repository's dedicated `automation-state` branch:
+
+- `coordination/registry.v1.json`
+- `coordination/registry.schema.json`
+
+The control branch belongs to this public repository. No private repository or other project is a
+coordination dependency.
+
+Before any automation-owned project write:
+
+1. Read current `main`, open PRs, recent merges, the target issue, and applicable `AGENTS.md` /
+   scientific/API documentation.
+2. Read the registry from `automation-state` together with its exact blob SHA.
+3. Acquire the lane mutex and every shared resource required for the intended mutation in one
+   SHA-guarded registry update.
+4. If the registry changed, re-read and retry the compare-and-swap at most three times.
+5. Never steal an unexpired lease. A lease may be reclaimed only after its `expiresAt` is at
+   least two minutes in the past.
+6. Use a lease duration no longer than 55 minutes. If work cannot safely finish inside that
+   window, stop at a clean boundary and continue on the next scheduled run rather than holding a
+   resource indefinitely.
+7. Release every registry entry carrying the exact `leaseId` when the task is merged, abandoned,
+   or safely stopped.
+
+If the registry cannot be read or validated, automation may inspect and plan but must not mutate
+the repository.
+
+## Resource names
+
+Every mutating run acquires exactly one lane mutex:
+
+- `lane:engine-science`
+- `lane:export-performance`
+
+Acquire additional shared resources only when the change touches them:
+
+- `shared:ci` — `.github/workflows/**`, CI policy/scripts, or test-runner configuration.
+- `shared:package` — root `package.json`, `package-lock.json`, package exports, or dependency
+  changes.
+- `shared:api-version` — `ENGINE_API_VERSION`, `POC_SIMULATION_API_VERSION`, or public schema
+  version surfaces.
+- `shared:changelog` — `CHANGELOG.md` when both lanes could plausibly update it.
+- `issue:<number>` — when mutating issue state/body/comments as part of active implementation.
+- `path:<repository-path>` — for another high-collision file not covered by a shared resource.
+
+Do not acquire broad resources speculatively. The registry is intended to prevent collisions, not
+serialize unrelated science and export work.
+
+## Branch and PR ownership
+
+Use focused branches:
+
+- Engine Science: `science/*`, `sensor/*`, `motion/*`, `optics/*`, or another clearly
+  science-owned prefix.
+- Export & Performance: `export/*`, `dng/*`, `perf/*`, or `ci/*`.
+
+Normally each lane has at most one active behavioral PR. Before creating new work, inspect existing
+open PRs and reuse an automation-owned branch/PR when it represents the same task.
+
+Never modify another lane's active branch. A dependent lane consumes prerequisite work only after it
+is merged to `main`, unless the project owner explicitly approves another integration path.
+
+After every merge, rescan open PRs and the relevant dependency issues before selecting the next task.
+
+## Cross-lane handoff
+
+When one lane lands a prerequisite for the other:
+
+1. Merge the prerequisite independently with its own tests and contract documentation.
+2. Record the exact merged commit and public API/contract surface on the dependent issue when a
+   handoff note materially helps.
+3. The dependent lane starts from current `main`; it does not continue on the prerequisite
+   lane's branch.
+4. If a downstream task exposes a missing scientific contract, Export & Performance records the
+   dependency and moves to independent work instead of implementing science locally.
+5. If Engine Science needs a benchmark/CI change, it records the requirement and lets Export &
+   Performance own the shared implementation unless the change is inseparable from the science
+   patch.
+
+## DCO and automated commits
+
+The repository requires Developer Certificate of Origin sign-off for commits intended for
+inclusion.
+
+Automation must fail closed rather than invent a contributor identity. When operating through the
+repository owner's authenticated GitHub connection under explicit owner authorization, use the
+owner's established DCO identity from existing signed-off commits. Otherwise, do not create a
+merge-intended commit until an authorized sign-off identity/path is available.
+
+Every automation-created merge-intended commit must contain a valid `Signed-off-by:` trailer.
+
+## Merge discipline
+
+Automation-owned non-breaking PRs may be merged only when:
+
+- the exact final head is current and mergeable;
+- required checks for that head are green;
+- no expected check is missing or silently skipped;
+- the complete final diff is reviewed;
+- the lane still owns every required lease;
+- issue dependencies are satisfied;
+- DCO sign-off is present;
+- scientific, provenance/licensing, security, browser/package-boundary, compatibility, and release
+  gates remain satisfied.
+
+Intentional breaking public API/schema changes, releases/publication, new paid services, ambiguous
+provenance/legal decisions, or other owner-gated actions still require explicit human approval.
+
+## Productive-run contract
+
+A scheduled implementation run is successful only when it produces at least one concrete delivery
+outcome:
+
+1. a safe roadmap PR is merged;
+2. an active roadmap PR contains substantive implementation/documentation changes and exact-head CI
+   is running or has produced actionable results;
+3. a roadmap issue is closed or materially narrowed with repository evidence because current
+   `main` already satisfies part or all of its acceptance criteria; or
+4. a specific blocker that truly requires external/human action is recorded with the exact missing
+   prerequisite and the lane immediately moves to another independent ready issue when one exists.
+
+A general audit, plan, status recap, repeated inspection, or rediscovery of an already-known blocker
+does **not** count as a productive outcome while actionable work exists.
+
+Before starting implementation, read the issue's latest **Roadmap reconciliation** section when
+present. Do not redo capabilities already verified on `main`. If reconciliation evidence shows the
+issue is already complete, close it with evidence and continue to the next ready issue in the same
+run when practical.
+
+## Stalled-progress rule
+
+A lane must not spend repeated scheduled runs on the same non-productive state.
+
+If two consecutive expected lane runs have produced none of the productive outcomes above:
+
+1. rescan current `main`, open PRs, recent merges, reconciliation state, dependencies, and leases;
+2. stop repeating the same audit or retry path;
+3. choose the next independent ready issue owned by the lane; or
+4. if no owned issue is actionable, record the precise blocker/dependency and surface it through the
+   health process.
+
+An ordinary CI failure, owned merge conflict, stale automation branch, test regression, or expired
+lease is an implementation problem to resolve, not by itself a reason to declare the lane blocked.
+Only owner-gated decisions, unavailable external prerequisites, unresolved legal/provenance
+questions, release gates, or another genuinely external dependency qualify as persistent blockers
+after safe remediation paths are exhausted.
+
+The health watch should treat an enabled/on-cadence lane with two consecutive scheduled windows and
+no concrete delivery outcome as potentially stalled when a reconciled ready issue exists. It should
+identify the lane and ready issue rather than disabling the lane.
+
+## Roadmap reconciliation discipline
+
+Open issues are the roadmap, but issue state must reflect current `main`.
+
+- Periodically reconcile issue acceptance criteria against merged implementation and tests.
+- Close an issue when all of its open-source acceptance criteria are demonstrably satisfied.
+- For partially completed issues, record the landed capability and the exact remaining scope in the
+  issue itself so future runs do not recreate completed work.
+- Unmerged historical branches are evidence to inspect, not authoritative project state.
+- A private/product requirement outside the current open-source scope does not keep an otherwise
+  completed public-engine issue open.
+- After reconciliation or a merge, select work from the remaining dependency graph rather than issue
+  age.
+
+## Avoiding coordination drift
+
+Do not duplicate scientific requirements or rewrite roadmap acceptance criteria in this document or
+the registry. If issue ownership/dependencies change, update the issue's coordination block and the
+automation prompt together. The issue remains authoritative for the work itself.

package/docs/IMAGE_FORMATION.md

@@ -99,6 +99,18 @@ Exposure duration and sensor readout timing are independent:
 
 This allows later rolling-shutter work to consume the same time-parameterized camera-motion model used for global exposure.
 
+The standalone `calculateSensorReadoutTiming()` foundation now supplies an invariant native-raster spatial readout phase schedule. Its first model is a caller-declared uniform-linear single-axis approximation with independently evidenced data-readout duration and rolling spatial skew. It does not define exposure windows or shutter-curtain motion, and it does not infer physical hardware readout lines from the effective native image raster.
+
+The additive `assessReadoutExposureTimingLinkage()` layer can validate an explicitly evidenced normalized spatial-phase relationship between rolling readout and an electronic exposure boundary. It never infers absolute temporal synchronization; total data-readout duration is not a surrogate for exposure timing, and matching direction/span alone is insufficient evidence of a shared clock.
+
+The standalone `calculateCaptureExposureWindows()` foundation separately describes local opening/closing exposure boundaries. It uses the first opening-boundary phase as its explicit time reference, preserves independent nominal/opening/closing timing, validates positive local duration across the whole active rectangle, and keeps mechanical/EFCS/electronic actuator identity separate from timing. It does not automatically bind those exposure boundaries to sensor readout phase or to the existing camera-rotation time origin.
+
+The standalone `calculateCaptureRotationTrajectories()` bridge now explicitly binds that first opening-boundary phase to `t = 0` of the existing pure-camera-rotation model and evaluates stationary reference rays at local exposure start/end. It remains forward temporal geometry only: it does not consume sensor readout timing, solve the implicit rolling-shutter image warp, or integrate motion blur over the exposure interval.
+
+The additive `calculateCaptureRotationInverseMappings()` layer now supplies an instantaneous destination-to-reference mapping at a caller-selected phase within each local exposure window. Under the current pure-rotation model the inverse is analytic once destination location fixes local capture time, so no iterative solver is used. This remains pre-lens, pre-output temporal geometry and does not replace finite-exposure integration.
+
+The additive `calculateCaptureRotationTemporalQuadrature()` layer now supplies deterministic uniform-midpoint time nodes and separate normalized-average/seconds-valued temporal measures across each local exposure. It preserves the instantaneous inverse mapping as the geometry source of truth but does not itself integrate radiance, visibility, shutter transmission, sensor response, PSF, or output pixels.
+
 ## Renderer semantics
 
 Renderer implementations may use a bounded real-time preview approximation or a higher-fidelity deterministic reference evaluation, but both must consume the same engine-owned scientific contract.
@@ -129,6 +141,20 @@ optical PSF
 
 Temporal exposure/readout couples into the photosite/charge stages rather than acting as an unrelated display blur.
 
+The standalone capture-mode profile now describes acquisition sequence, per-frame effective sampling, optional inter-frame sensor offsets, reconstruction-stage labels, processed-image raster, and downstream dependencies. It does **not** implement the reserved CFA/photosite/reconstruction algorithms. A mode's processed raster remains upstream of physical orientation and final output crop/resampling and cannot redefine physical sensor geometry or FOV.
+
+The standalone color-sampling topology profile now describes monochrome, arbitrary periodic mosaic phase/channel assignment, and layered color declarations with an explicitly unresolved spatial relationship. The periodic topology lives on a distinct native sensor sampling-site lattice rather than `NativeImageRaster`; no binding to effective image samples or physical photodiodes is inferred. This metadata foundation does not yet implement the reserved photosite/CFA sampling stage, spectral response, sparse site exceptions, RAW sampling, or reconstruction.
+
+The additive native-effective-raster/color-site binding now provides the missing structural bridge between capture-mode effective samples and monochrome/periodic topology. It requires evidence for the exact native raster relationship and grouped-mode phase, preserves full-frame absolute CFA phase, and reports compact pre-reconstruction source regions/channel counts. This still does **not** implement the reserved photosite/CFA sampling stage: no signal weights, spectral response, photons/electrons, RAW values, aliasing, or reconstruction are calculated.
+
+The standalone sensor optical-stack profile now makes the upstream stack boundary explicit without claiming a complete stack response. Ordered physical component roles and microlens presence are descriptive. Effective anti-aliasing response is separately modeled as unknown, absent, present-but-unresolved, or a normalized native-physical point-splitting approximation. The resolver exposes only that AA spatial term; cover/filter transmission/refraction, microlens angular/collection behavior, wavelength/field/polarization dependence, and convolution with the lens PSF remain future work. Consequently the `sensor-optical-stack` image-formation stage remains reserved rather than being promoted to a complete implementation.
+
+The standalone sensor sampling-aperture profile now supplies explicit native-physical registration for the color-site center lattice and a first geometric sensitive-region footprint. The rectangle is a normalized spatial-area averaging support plus a separately reported geometric area/fraction; it is **not** QE or radiometric collection efficiency. AA point splitting, microlens redirection, diffusion/crosstalk, spectral response, photons/electrons, and RAW values are still absent. This advances the geometry needed by the reserved `photosite-cfa-sampling` stage without claiming that stage is fully implemented.
+
+The additive sensor spatial-quadrature layer now combines the resolved AA point-splitting term with the geometric aperture using deterministic native-physical midpoint nodes. AA is applied by inverse source lookup, the destination site's CFA channel remains fixed, and off-active-area pre-AA source support is preserved. The result is still a geometry/measure plan only: no optical field, spectral response, radiometry, temporal integration, RAW value, or reconstruction is calculated, so the `photosite-cfa-sampling` stage remains reserved.
+
+The additive spatial-sample reducer can now apply those weights to caller-supplied nonnegative linear relative values or physical irradiance. It does not turn a channel ID into spectral filtering, does not integrate over time/wavelength, and does not calculate photons, electrons or RAW codes. Consequently this is still a pre-response site sample and the full `photosite-cfa-sampling` stage remains reserved.
+
 ## Current implementation status
 
 Each stage is labeled:

package/docs/MOTION_AND_SIGNAL.md

@@ -51,6 +51,148 @@ This is camera **rotation only**. Translation is excluded because parallax requi
 
 The returned image-plane/sample components use +X right and +Y up. Native raster remains +X right/+Y down and requires the existing explicit coordinate transform at capture composition boundaries.
 
+## Sensor readout timing
+
+`calculateSensorReadoutTiming()` provides a standalone capture-specific **native sensor scan-timing** foundation.
+
+The model deliberately separates two evidence-backed seconds-valued facts:
+
+- **capture data-readout duration** — the caller's declared duration for the selected capture mode's sensor data-readout operation;
+- **rolling spatial-sampling skew** — the timing span that drives the first-to-last spatial scan phase in the current approximation.
+
+Photivra does not assume those values are equal, and it does not infer an ordering relationship between them. For global readout, spatial skew is zero in this model even when the declared data-readout duration is non-zero.
+
+For rolling readout, the caller also supplies an independently evidenced native scan direction. The current schedule is a `uniform-linear-single-axis` approximation over continuous native raster edge coordinates. This is intentionally **not** a claim that one `NativeImageRaster` row/column equals one physical photodiode row or one hardware readout line. Segmented, center-out, interleaved, multi-tap and other non-uniform schedules remain unsupported rather than being silently approximated as equivalent hardware.
+
+Native sensor timing is orientation-invariant. `calculateSensorReadoutTiming()` therefore does not accept physical camera orientation or output raster geometry. When presentation/capture orientation is needed, callers compose the returned native direction vector with the existing native-to-oriented vector transform. Digital output crop/resolution cannot alter the native timing schedule.
+
+Active-capture timing is also explicit: Photivra never scales a full-frame timing fact by crop dimensions to invent a cropped-mode timing. A caller must provide timing evidence appropriate to the selected capture mode/active area; later capture-mode work can bind those declarations more formally.
+
+Mechanical, electronic-first-curtain and fully electronic shutter mechanisms are reported independently but remain scientifically inert in this slice. The function does **not** define local exposure start/end times, mechanical curtain travel, EFCS curtain interaction, rolling-shutter image distortion, flash/flicker bands, or motion integration. Those later models must combine their own timing with this sensor schedule explicitly rather than treating sensor readout as a surrogate shutter-curtain model.
+
+## Readout/exposure spatial linkage
+
+`assessReadoutExposureTimingLinkage()` is the explicit boundary between the native sensor readout schedule and the capture exposure-window schedule.
+
+The contract deliberately distinguishes **spatial phase/order** from **absolute temporal synchronization**.
+
+A caller may declare:
+
+- `unlinked` — Photivra asserts no relationship for this capture. This is not evidence that the physical processes are independent.
+- `spatial-phase-linked` — one or more electronic exposure boundaries are asserted to share the rolling readout's normalized native spatial phase, either in the same direction or reversed.
+
+Every positive link carries its own provenance. The underlying readout direction/skew and exposure-boundary direction/traversal facts keep their own separate evidence.
+
+A positive spatial-phase link is valid only when:
+
+- sensor readout is rolling and therefore has a spatial scan;
+- the selected exposure boundary is electronic;
+- the selected exposure boundary is itself a uniform-linear native scan;
+- `same` phase orientation uses the same native scan direction;
+- `reversed` phase orientation uses the exact opposite direction on the same native axis.
+
+The rolling-readout spatial skew and exposure-boundary traversal duration do **not** have to be equal. Their dimensionless ratio is reported diagnostically. A ratio of 1 still does not prove a shared clock origin or temporal coincidence.
+
+`captureReadoutDurationSeconds` is preserved with units/evidence but is never used to validate an exposure linkage. Data transfer/readout duration can describe a different physical interval from exposure-boundary traversal.
+
+Absolute temporal alignment remains `not-established` in this foundation. A future mode profile may supply an evidence-backed temporal offset/synchronization relationship if defensible data exists, but Photivra will not infer it from shutter mechanism, scan direction, matching timing spans, output resolution, or adjacent camera specifications.
+
+## Capture exposure windows
+
+`calculateCaptureExposureWindows()` adds the next standalone timing layer after native sensor readout timing.
+
+It represents **opening and closing exposure boundaries separately**. Each boundary can currently be simultaneous or a caller-declared uniform-linear scan in invariant native sensor coordinates. The nominal exposure duration is another independent evidence-backed seconds-valued quantity.
+
+The output time reference is the **first opening-boundary phase**, not a claim that every native location has the same local exposure start. For each point, local start and end offsets are derived independently, and the engine reports local exposure duration.
+
+Mechanical, EFCS, and electronic shutter mechanisms determine only which conceptual actuator owns the opening/closing boundary. They do not invent traversal timing:
+
+- mechanical: mechanical opening and closing;
+- EFCS: electronic opening, mechanical closing;
+- electronic: electronic opening and closing.
+
+The complete active rectangle is validated so a zero/negative local exposure duration cannot hide in an unsampled region.
+
+This contract remains deliberately separate from `calculateSensorReadoutTiming()`. Sensor readout phase is not automatically an exposure boundary. It also remains separate from `calculateCameraRotationImageMapping()`: that API still accepts seconds from its existing exposure-start reference, and a later integration layer must define how local capture-window times bind to that motion time basis.
+
+The first exposure-window model does not include curtain acceleration, nonlinear or segmented electronic scheduling, flash/flicker interaction, shutter shock, EFCS-specific pupil/bokeh behavior, or rolling-shutter image distortion.
+
+## Capture rotation exposure trajectories
+
+`calculateCaptureRotationTrajectories()` is the first explicit integration between local capture exposure windows and the existing pure-camera-rotation mapping.
+
+For each caller-selected native raster point, the engine:
+
+1. resolves the point's local exposure start/end with `calculateCaptureExposureWindows()`;
+2. maps that native point into the pre-orientation image plane at the **first opening-boundary phase**;
+3. explicitly binds that capture reference to `t = 0` of `calculateCameraRotationImageMapping()` for this composition;
+4. evaluates the same stationary world ray at the local exposure start and end;
+5. reports the two mapped endpoints plus their image-plane chord.
+
+The output is deliberately a **forward stationary-reference-ray trajectory**, not a rolling-shutter image warp.
+
+That distinction matters because in a rolling capture the exposure/capture time depends on image location while camera motion also changes where a world ray lands. A renderer-ready rolling-shutter transform therefore requires a self-consistent inverse destination-to-source mapping rather than one forward displacement evaluated at a destination coordinate.
+
+The endpoint chord also is **not a blur kernel**. Pure rotational image motion can follow a curved image-plane path, and exposure integrates radiance over the entire local interval rather than only its two endpoints.
+
+Sensor data-readout timing from `calculateSensorReadoutTiming()` is intentionally absent. A particular electronic capture mode may have a documented relationship between sensor readout and exposure boundaries, but Photivra will require that relationship to be declared explicitly rather than assuming it universally.
+
+The trajectory foundation remains rotation-only. Camera translation/parallax, subject motion, panning intent, object rotation/deformation, occlusion changes, exposure integration, flash/flicker, shutter shock, and the final inverse rolling-shutter warp remain future work.
+
+## Capture rotation temporal quadrature
+
+`calculateCaptureRotationTemporalQuadrature()` extends the instantaneous inverse mapping into a deterministic **temporal-geometry quadrature** over each destination point's complete local exposure interval.
+
+The first model uses the uniform midpoint rule. For `N` temporal samples, normalized local phases are:
+
+```text
+phase_i = (i + 0.5) / N
+```
+
+so the exact opening and closing boundaries are not sampled. Each phase is evaluated through the already-public `calculateCaptureRotationInverseMappings()` contract rather than introducing a second camera-motion equation.
+
+Every temporal node reports two different measures:
+
+- `normalizedTimeWeight = 1 / N` — dimensionless weight for a downstream **time average** under the declared uniform temporal-response approximation;
+- `timeMeasureSeconds = localExposureDuration / N` — seconds-valued `dt` measure for a downstream **time integral**.
+
+These are intentionally separate. The seconds-valued measure is not shutter transmission, photon count, radiometric throughput, scene radiance, sensor response, or a calibrated energy measurement.
+
+The local exposure interval remains destination-dependent. A scanned opening/closing schedule can therefore shift node times between sensor locations, and different opening/closing traversal schedules can produce different local durations and therefore different `timeMeasureSeconds` values.
+
+The first temporal-response model is `uniform-over-local-exposure`. That is an explicit approximation. Photivra does not yet model shutter-transmission ramps, exposure-dependent sensor response, scene flicker, flash pulses, or other time-varying radiometric weighting.
+
+The API returns **nodes and weights only**. It does not average reference coordinates, compute a blur radius/kernel, sample scene radiance, resolve visibility/occlusion, or write output pixels. Averaging geometric coordinates is not a substitute for integrating the radiance seen along the time-varying rays.
+
+No geometry-only quadrature error estimate is reported. Image-integration error depends on downstream scene radiance, visibility, texture/edge frequency, and reconstruction as well as the camera trajectory. Renderer/reference implementations can compare increasing temporal sample counts in their radiance domain when convergence evidence is needed.
+
+## Instantaneous capture rotation inverse mapping
+
+`calculateInverseCameraRotationImageMapping()` is the exact inverse of the existing forward pure-rotation ray mapping under the same constant-axis assumptions. Once capture time is known, the captured image-plane ray is rotated analytically back into the exposure-start reference camera frame. There is no numerical root/fixed-point solve.
+
+`calculateCaptureRotationInverseMappings()` composes that inverse with local exposure-window timing.
+
+For each destination native sensor point:
+
+1. the destination point selects its local exposure window;
+2. the caller supplies `localExposurePhase` in `[0, 1]`;
+3. capture time is `start + phase × localDuration`;
+4. the destination native point is mapped into the ideal pre-lens image plane;
+5. the captured ray is analytically inverted to the first-opening-boundary reference frame;
+6. image-plane, native effective-sample, and physically oriented sample displacements are reported.
+
+The phase is mandatory because a finite exposure has no single sharp geometry. Phase `0` means local exposure start, `0.5` is the local temporal midpoint, and `1` is local exposure end. None is automatically privileged as the final rendered image.
+
+This inverse is renderer-oriented in the limited sense that it maps **destination capture location -> reference ray**. It still is not a finite-exposure renderer. Motion blur requires integration over the local interval, with an explicit exposure-weighting model if weighting is not uniform.
+
+Sensor data-readout timing remains absent. A documented mode-specific relationship may later link readout and electronic exposure timing, but no such equality is assumed here.
+
+The mapping is evaluated in the ideal pre-lens image plane. Radial distortion, chromatic aberration, PSF, output crop/resampling, camera translation/parallax, subject motion, occlusion changes, flash/flicker and shutter shock remain separate stages.
+
+Reference rays are not clamped to the active source frame. Under camera motion, a valid captured destination can map to reference geometry outside the available reference image; a renderer must treat that as missing source coverage rather than silently stretching or clamping edge pixels.
+
+The current inverse does not claim that an arbitrary rolling/capture-scan camera is globally one-to-one. More general motion models can produce folds, repeated visibility or other multi-perspective behavior; those cases require additional validity analysis rather than being inferred from this pure-rotation slice.
+
 ## Temporal image-formation basis
 
 The image-formation contract defines physical time in **seconds from exposure start**.