@photivra/engine 0.5.1 → 1.0.0

package/dist/sensor/eqe-local-exposure.js

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Module boundary and integration notes.
+ * Compose validated irradiance reduction, response applicability/range, EQE conversion and stationary
+ * local integration. The exposure value is suitable for accumulated-charge photoSignal;
+ * dark/completeness/capacity/readout remain explicit downstream inputs. Invalid or unsupported
+ * evidence fails closed.
+ * Internal shared instantaneous path; no stationarity or exposure accumulation.
+ * @see docs/MOTION_AND_SIGNAL.md for equations, coordinate/unit conventions, blockers and support
+ * limits.
+ */
+import { approximationResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError } from "../core/validation.js";
+import { calculateSensorSpatialSamplingQuadrature } from "./spatial-sampling-quadrature.js";
+import { calculateSensorSpectralQuadrature } from "./spectral-quadrature.js";
+import { reduceSensorSpatioSpectralIrradiance } from "./spatio-spectral-reduction.js";
+import { assessSensorResponseApplicationCompatibility } from "./response-application-compatibility.js";
+import { assessSensorResponseOperatingRange } from "./response-operating-range.js";
+import { calculateSensorEqeElectronRate } from "./eqe-electron-rate.js";
+import { bindSensorRateToLocalExposure } from "./local-exposure-binding.js";
+import { integrateStationarySensorRateOverLocalExposure } from "./constant-rate-temporal-integration.js";
+/**
+ * Compose validated irradiance reduction, response applicability/range, EQE
+ * conversion and stationary local integration. The exposure value is suitable
+ * for accumulated-charge photoSignal; dark/completeness/capacity/readout remain
+ * explicit downstream inputs. Invalid or unsupported evidence fails closed.
+ */
+export function calculateSensorEqeLocalExposure(input) {
+    const stages = calculateSensorEqeLocalRate(input);
+    const { spatialQuadrature, spectralQuadrature, reduction, compatibility, operatingRange, electronRate, exposureBinding } = stages;
+    const exposure = integrateStationarySensorRateOverLocalExposure({
+        rate: electronRate.value, exposureBinding: exposureBinding.value,
+        stationarityProfile: input.stationarityProfile
+    });
+    if (exposure.value.kind !== "eqe-expected-counts") {
+        throw new InvalidScientificInputError("EQE local exposure requires expected electron counts.");
+    }
+    return approximationResult({
+        upstreamOrigin: "declared-spatio-spectral-irradiance-samples",
+        upstreamSceneAndOpticsVerified: false,
+        spatialQuadrature, spectralQuadrature, reduction, compatibility, operatingRange, electronRate, exposureBinding,
+        exposure: { ...exposure, value: exposure.value }
+    }, "sensor-eqe-local-exposure-composition", "0.1.0", [
+        "Irradiance node values and upstream scene/optics origin are declared, not verified.",
+        "Finite quadrature and explicit response/stationarity evidence retain their child limitations.",
+        "Uncertainty and quadrature convergence errors are not propagated or combined."
+    ]);
+}
+/** Internal shared instantaneous path; no stationarity or exposure accumulation. */
+export function calculateSensorEqeLocalRate(input) {
+    const spatialQuadrature = calculateSensorSpatialSamplingQuadrature({
+        ...input.spatialSampling, colorSamplingProfile: input.colorSamplingProfile,
+        colorSamplingBindingProfile: input.localExposure.bindingProfile,
+        nativeRaster: input.localExposure.exposureWindowInput.nativeRaster
+    });
+    const spectralQuadrature = calculateSensorSpectralQuadrature({
+        ...input.spectralSampling, colorSamplingProfile: input.colorSamplingProfile,
+        spectralResponseProfile: input.spectralResponseProfile
+    });
+    const reduction = reduceSensorSpatioSpectralIrradiance({
+        spatialQuadrature: spatialQuadrature.value, spectralQuadrature: spectralQuadrature.value,
+        sampleValues: input.irradianceSamples
+    });
+    const compatibility = assessSensorResponseApplicationCompatibility({
+        ...input.responseApplication, reduction: reduction.value
+    });
+    const operatingRange = assessSensorResponseOperatingRange({
+        reduction: reduction.value, compatibility: compatibility.value,
+        operatingRangeProfile: input.operatingRangeProfile
+    });
+    const electronRate = calculateSensorEqeElectronRate({
+        reduction: reduction.value, compatibility: compatibility.value,
+        operatingRange: operatingRange.value,
+        colorSamplingProfile: input.colorSamplingProfile,
+        spectralResponseProfile: input.spectralResponseProfile,
+        ...(input.airPhotonEnergyContext === undefined ? {} : { airPhotonEnergyContext: input.airPhotonEnergyContext })
+    });
+    const exposureBinding = bindSensorRateToLocalExposure({
+        ...input.localExposure, rate: electronRate.value,
+        colorSamplingProfile: input.colorSamplingProfile
+    });
+    return { spatialQuadrature, spectralQuadrature, reduction, compatibility, operatingRange, electronRate, exposureBinding };
+}
+//# sourceMappingURL=eqe-local-exposure.js.map

package/dist/sensor/eqe-local-exposure.js.map

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

package/dist/sensor/eqe-temporal-exposure.d.ts

@@ -0,0 +1,55 @@
+import { type CalculationResult } from "../core/calculation-result.js";
+import { calculateSensorEqeLocalRate, type CalculateSensorEqeLocalExposureInput } from "./eqe-local-exposure.js";
+/** Shared response/site/shutter state, with separately evaluated physical light at each time. */
+export interface CalculateSensorEqeTemporalExposureInput extends Omit<CalculateSensorEqeLocalExposureInput, "irradianceSamples" | "stationarityProfile"> {
+    /** Complete uniform-midpoint coverage; array order is not temporal identity. */
+    samples: readonly {
+        temporalSampleIndex: number;
+        /** Seconds on the shutter's first-opening-boundary-phase reference. */
+        timeSecondsFromOpeningReference: number;
+        /** Complete W/m²/nm Cartesian irradiance coverage for this instant. */
+        irradianceSamples: CalculateSensorEqeLocalExposureInput["irradianceSamples"];
+    }[];
+}
+/** Nonstationary photo expectation, deliberately distinct from stationary RAW producer inputs. */
+export interface SensorEqeTemporalExposure {
+    kind: "eqe-temporal-quadrature-expected-counts";
+    colorSamplingProfileId: string;
+    channelId: string;
+    site: {
+        x: number;
+        y: number;
+    };
+    bindingId: string;
+    timeReference: "first-opening-boundary-phase";
+    startOffsetSecondsFromOpeningReference: number;
+    endOffsetSecondsFromOpeningReference: number;
+    localExposureDurationSeconds: number;
+    expectedIncidentPhotonCount: number;
+    expectedGeneratedElectronCount: number;
+    integrationMethod: "uniform-midpoint-rate-quadrature";
+    timeStationarityEstablished: false;
+    timeVaryingSignalIntegrated: true;
+    temporalIntegrationApplied: true;
+    upstreamSceneAndOpticsVerified: false;
+    accumulatedSignalCompleteness: "photo-signal-only";
+    physicalFullWellAssessmentAuthorized: false;
+    shotNoiseApplied: false;
+    rawCodeValueProduced: false;
+    /** Canonical order, seconds-valued integration measures and independent child evidence. */
+    samples: readonly {
+        temporalSampleIndex: number;
+        timeSecondsFromOpeningReference: number;
+        integrationMeasureSeconds: number;
+        timeAverageWeight: number;
+        stages: ReturnType<typeof calculateSensorEqeLocalRate>;
+    }[];
+}
+/**
+ * Evaluate response validity and EQE independently at each declared shutter
+ * midpoint, then sum rates times seconds. This is quadrature, not a stationarity
+ * claim or convergence proof. Shared profile/geometry state prevents combining
+ * rates from different sites or shutter events. No renderer executes here.
+ */
+export declare function calculateSensorEqeTemporalExposure(input: CalculateSensorEqeTemporalExposureInput): CalculationResult<SensorEqeTemporalExposure>;
+//# sourceMappingURL=eqe-temporal-exposure.d.ts.map

package/dist/sensor/eqe-temporal-exposure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eqe-temporal-exposure.d.ts","sourceRoot":"","sources":["../../src/sensor/eqe-temporal-exposure.ts"],"names":[],"mappings":"AAcA,OAAO,EAAuB,KAAK,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAE5F,OAAO,EAAE,2BAA2B,EAAE,KAAK,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAEjH,iGAAiG;AACjG,MAAM,WAAW,uCACf,SAAQ,IAAI,CAAC,oCAAoC,EAAE,mBAAmB,GAAG,qBAAqB,CAAC;IAC/F,gFAAgF;IAChF,OAAO,EAAE,SAAS;QAChB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,uEAAuE;QACvE,+BAA+B,EAAE,MAAM,CAAC;QACxC,uEAAuE;QACvE,iBAAiB,EAAE,oCAAoC,CAAC,mBAAmB,CAAC,CAAC;KAC9E,EAAE,CAAC;CACL;AAED,kGAAkG;AAClG,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,yCAAyC,CAAC;IAChD,sBAAsB,EAAE,MAAM,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,8BAA8B,CAAC;IAC9C,sCAAsC,EAAE,MAAM,CAAC;IAC/C,oCAAoC,EAAE,MAAM,CAAC;IAC7C,4BAA4B,EAAE,MAAM,CAAC;IACrC,2BAA2B,EAAE,MAAM,CAAC;IACpC,8BAA8B,EAAE,MAAM,CAAC;IACvC,iBAAiB,EAAE,kCAAkC,CAAC;IACtD,2BAA2B,EAAE,KAAK,CAAC;IACnC,2BAA2B,EAAE,IAAI,CAAC;IAClC,0BAA0B,EAAE,IAAI,CAAC;IACjC,8BAA8B,EAAE,KAAK,CAAC;IACtC,6BAA6B,EAAE,mBAAmB,CAAC;IACnD,oCAAoC,EAAE,KAAK,CAAC;IAC5C,gBAAgB,EAAE,KAAK,CAAC;IACxB,oBAAoB,EAAE,KAAK,CAAC;IAC5B,2FAA2F;IAC3F,OAAO,EAAE,SAAS;QAChB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,+BAA+B,EAAE,MAAM,CAAC;QACxC,yBAAyB,EAAE,MAAM,CAAC;QAClC,iBAAiB,EAAE,MAAM,CAAC;QAC1B,MAAM,EAAE,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC;KACxD,EAAE,CAAC;CACL;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,uCAAuC,GAC7C,iBAAiB,CAAC,yBAAyB,CAAC,CAwC9C"}

package/dist/sensor/eqe-temporal-exposure.js

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Module boundary and integration notes.
+ * Evaluate response validity and EQE independently at each declared shutter midpoint, then sum rates
+ * times seconds. This is quadrature, not a stationarity claim or convergence proof. Shared
+ * profile/geometry state prevents combining rates from different sites or shutter events. No renderer
+ * executes here.
+ * @see docs/MOTION_AND_SIGNAL.md for equations, coordinate/unit conventions, blockers and support
+ * limits.
+ */
+import { sumTemporalEqeRateExpectations } from "./temporal-eqe-sum.js";
+import { bindSensorTemporalSamples } from "./temporal-sample-binding.js";
+import { approximationResult } from "../core/calculation-result.js";
+import { InvalidScientificInputError } from "../core/validation.js";
+import { calculateSensorEqeLocalRate } from "./eqe-local-exposure.js";
+/**
+ * Evaluate response validity and EQE independently at each declared shutter
+ * midpoint, then sum rates times seconds. This is quadrature, not a stationarity
+ * claim or convergence proof. Shared profile/geometry state prevents combining
+ * rates from different sites or shutter events. No renderer executes here.
+ */
+export function calculateSensorEqeTemporalExposure(input) {
+    const ordered = bindSensorTemporalSamples(input.samples, sample => sample.irradianceSamples);
+    const count = ordered.length;
+    const samples = [];
+    let previousTime = -Infinity;
+    for (let index = 0; index < count; index++) {
+        const sample = ordered[index];
+        const stages = calculateSensorEqeLocalRate({ ...input, irradianceSamples: sample.irradianceSamples });
+        const binding = stages.exposureBinding.value;
+        const start = binding.localExposureWindow.startOffsetSecondsFromOpeningReference;
+        const measure = binding.localExposureDurationSeconds / count;
+        const time = start + (index + 0.5) * measure;
+        // Exact shared construction rejects stale/global-clock samples without an implicit tolerance.
+        if (sample.timeSecondsFromOpeningReference !== time || !Number.isFinite(measure) || measure <= 0 ||
+            !(time > start && time > previousTime && time < binding.localExposureWindow.endOffsetSecondsFromOpeningReference)) {
+            throw new InvalidScientificInputError("Temporal sample must match its representable local shutter midpoint exactly.");
+        }
+        previousTime = time;
+        samples.push({ temporalSampleIndex: index, timeSecondsFromOpeningReference: time,
+            integrationMeasureSeconds: measure, timeAverageWeight: 1 / count, stages });
+    }
+    const { photonCount, electronCount } = sumTemporalEqeRateExpectations(samples.map(s => s.stages.electronRate.value), samples[0].integrationMeasureSeconds);
+    const binding = samples[0].stages.exposureBinding.value;
+    return approximationResult({ kind: "eqe-temporal-quadrature-expected-counts",
+        colorSamplingProfileId: binding.colorSamplingProfileId, channelId: binding.channelId, site: { ...binding.site },
+        bindingId: binding.bindingId, timeReference: "first-opening-boundary-phase",
+        startOffsetSecondsFromOpeningReference: binding.localExposureWindow.startOffsetSecondsFromOpeningReference,
+        endOffsetSecondsFromOpeningReference: binding.localExposureWindow.endOffsetSecondsFromOpeningReference,
+        localExposureDurationSeconds: binding.localExposureDurationSeconds,
+        expectedIncidentPhotonCount: photonCount, expectedGeneratedElectronCount: electronCount,
+        integrationMethod: "uniform-midpoint-rate-quadrature", timeStationarityEstablished: false,
+        timeVaryingSignalIntegrated: true, temporalIntegrationApplied: true, upstreamSceneAndOpticsVerified: false,
+        accumulatedSignalCompleteness: "photo-signal-only", physicalFullWellAssessmentAuthorized: false,
+        shotNoiseApplied: false, rawCodeValueProduced: false, samples
+    }, "sensor-eqe-temporal-exposure", "0.1.0", [
+        "Irradiance at each time is declared; scene transport, projection and PSF execution are not verified.",
+        "Uniform midpoint quadrature has no asserted convergence bound or combined uncertainty.",
+        "Nonstationary counts are not the existing stationary charge/RAW producer contract; downstream integration remains required."
+    ]);
+}
+//# sourceMappingURL=eqe-temporal-exposure.js.map

package/dist/sensor/eqe-temporal-exposure.js.map

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

package/dist/sensor/exposure-window.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Module boundary and integration notes.
+ * Resolves local capture exposure windows from independent opening and closing boundary schedules. The
+ * returned time basis is seconds from the first opening-boundary phase. This is intentionally not the
+ * existing camera-rotation API's global "exposure start" semantic; a later integration layer must bind
+ * those time bases explicitly. The mechanism identifies whether each boundary is mechanical or
+ * electronic, but does not supply any traversal duration or direction. Every non-simultaneous timing
+ * value and direction is caller-declared with evidence. The first model supports simultaneous
+ * boundaries and uniform-linear single-axis native-sensor scans only. It does not model curtain
+ * acceleration, segmented/nonlinear electronic schedules, flash/flicker, rolling-shutter image
+ * distortion, shutter shock, or EFCS-specific pupil/bokeh behavior.
+ * @see docs/MOTION_AND_SIGNAL.md for equations, coordinate/unit conventions, blockers and support
+ * limits.
+ */
+import { type CalculationResult } from "../core/calculation-result.js";
+import { type EvidenceBackedFact } from "../core/evidence-provenance.js";
+import type { RasterPoint, RasterRect, RasterVector } from "../output/capture-geometry.js";
+import type { NativeImageRaster } from "./sensor-geometry.js";
+import type { CaptureShutterMechanism, NativeSensorReadoutScanDirection, SourcedSensorTimingSeconds } from "./readout-timing.js";
+export type CaptureExposureBoundaryActuator = "mechanical" | "electronic";
+export type SourcedCaptureTimingSeconds = SourcedSensorTimingSeconds;
+export type SourcedCaptureBoundaryDirection = EvidenceBackedFact<NativeSensorReadoutScanDirection>;
+export interface SimultaneousExposureBoundarySchedule {
+    kind: "simultaneous";
+    directionNative?: never;
+    traversalDurationSeconds?: never;
+}
+export interface UniformLinearExposureBoundarySchedule {
+    kind: "uniform-linear-native-scan";
+    directionNative: SourcedCaptureBoundaryDirection;
+    traversalDurationSeconds: SourcedCaptureTimingSeconds;
+}
+export type ExposureBoundarySchedule = SimultaneousExposureBoundarySchedule | UniformLinearExposureBoundarySchedule;
+export interface CalculateCaptureExposureWindowsInput {
+    nativeRaster: NativeImageRaster;
+    /**
+     * Active capture rectangle in invariant native-raster coordinates.
+     *
+     * Defaults to the complete native raster. Boundary traversal timing is never
+     * inferred by scaling a full-frame timing value to this rectangle.
+     */
+    activeCaptureRect?: RasterRect;
+    shutterMechanism: CaptureShutterMechanism;
+    /**
+     * Nominal interval between the zero-phase opening and closing references.
+     *
+     * Local exposure duration may differ from this value when opening and closing
+     * boundary schedules have different spatial phase behavior.
+     */
+    nominalExposureDurationSeconds: SourcedCaptureTimingSeconds;
+    opening: ExposureBoundarySchedule;
+    closing: ExposureBoundarySchedule;
+    /**
+     * Optional continuous native raster edge-coordinate points for diagnostics.
+     * Pixel centers may be represented with +0.5 offsets.
+     */
+    samplePointsNative?: readonly RasterPoint[];
+}
+export interface ResolvedCaptureExposureBoundary {
+    actuator: CaptureExposureBoundaryActuator;
+    schedule: {
+        kind: "simultaneous";
+    } | {
+        kind: "uniform-linear-native-scan";
+        directionNative: SourcedCaptureBoundaryDirection;
+        unitVectorNative: RasterVector;
+        traversalDurationSeconds: SourcedCaptureTimingSeconds;
+    };
+}
+export interface CaptureExposureWindowSample {
+    pointNative: RasterPoint;
+    openingNormalizedScanPosition: number | null;
+    closingNormalizedScanPosition: number | null;
+    /**
+     * Seconds from the first opening-boundary phase.
+     */
+    startOffsetSecondsFromOpeningReference: number;
+    /**
+     * Seconds from the first opening-boundary phase.
+     */
+    endOffsetSecondsFromOpeningReference: number;
+    localExposureDurationSeconds: number;
+}
+export interface CaptureExposureWindows {
+    shutterMechanism: CaptureShutterMechanism;
+    timeReference: "first-opening-boundary-phase";
+    nativeRaster: NativeImageRaster;
+    activeCaptureRect: RasterRect;
+    nominalExposureDurationSeconds: SourcedCaptureTimingSeconds;
+    opening: ResolvedCaptureExposureBoundary;
+    closing: ResolvedCaptureExposureBoundary;
+    localExposureDurationRangeSeconds: {
+        minimum: number;
+        maximum: number;
+    };
+    samples: readonly CaptureExposureWindowSample[];
+}
+/**
+ * Resolves local capture exposure windows from independent opening and closing
+ * boundary schedules.
+ *
+ * The returned time basis is seconds from the first opening-boundary phase.
+ * This is intentionally not the existing camera-rotation API's global
+ * "exposure start" semantic; a later integration layer must bind those time
+ * bases explicitly.
+ *
+ * The mechanism identifies whether each boundary is mechanical or electronic,
+ * but does not supply any traversal duration or direction. Every non-simultaneous
+ * timing value and direction is caller-declared with evidence.
+ *
+ * The first model supports simultaneous boundaries and uniform-linear
+ * single-axis native-sensor scans only. It does not model curtain acceleration,
+ * segmented/nonlinear electronic schedules, flash/flicker, rolling-shutter
+ * image distortion, shutter shock, or EFCS-specific pupil/bokeh behavior.
+ */
+export declare function calculateCaptureExposureWindows(input: CalculateCaptureExposureWindowsInput): CalculationResult<CaptureExposureWindows>;
+//# sourceMappingURL=exposure-window.d.ts.map

package/dist/sensor/exposure-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exposure-window.d.ts","sourceRoot":"","sources":["../../src/sensor/exposure-window.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,gCAAgC,CAAC;AAKxC,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,YAAY,EACb,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EACV,uBAAuB,EACvB,gCAAgC,EAChC,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,+BAA+B,GAAG,YAAY,GAAG,YAAY,CAAC;AAE1E,MAAM,MAAM,2BAA2B,GAAG,0BAA0B,CAAC;AAErE,MAAM,MAAM,+BAA+B,GACzC,kBAAkB,CAAC,gCAAgC,CAAC,CAAC;AAEvD,MAAM,WAAW,oCAAoC;IACnD,IAAI,EAAE,cAAc,CAAC;IACrB,eAAe,CAAC,EAAE,KAAK,CAAC;IACxB,wBAAwB,CAAC,EAAE,KAAK,CAAC;CAClC;AAED,MAAM,WAAW,qCAAqC;IACpD,IAAI,EAAE,4BAA4B,CAAC;IACnC,eAAe,EAAE,+BAA+B,CAAC;IACjD,wBAAwB,EAAE,2BAA2B,CAAC;CACvD;AAED,MAAM,MAAM,wBAAwB,GAChC,oCAAoC,GACpC,qCAAqC,CAAC;AAE1C,MAAM,WAAW,oCAAoC;IACnD,YAAY,EAAE,iBAAiB,CAAC;IAChC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,UAAU,CAAC;IAC/B,gBAAgB,EAAE,uBAAuB,CAAC;IAC1C;;;;;OAKG;IACH,8BAA8B,EAAE,2BAA2B,CAAC;IAC5D,OAAO,EAAE,wBAAwB,CAAC;IAClC,OAAO,EAAE,wBAAwB,CAAC;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,EAAE,+BAA+B,CAAC;IAC1C,QAAQ,EACJ;QACE,IAAI,EAAE,cAAc,CAAC;KACtB,GACD;QACE,IAAI,EAAE,4BAA4B,CAAC;QACnC,eAAe,EAAE,+BAA+B,CAAC;QACjD,gBAAgB,EAAE,YAAY,CAAC;QAC/B,wBAAwB,EAAE,2BAA2B,CAAC;KACvD,CAAC;CACP;AAED,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,WAAW,CAAC;IACzB,6BAA6B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,6BAA6B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C;;OAEG;IACH,sCAAsC,EAAE,MAAM,CAAC;IAC/C;;OAEG;IACH,oCAAoC,EAAE,MAAM,CAAC;IAC7C,4BAA4B,EAAE,MAAM,CAAC;CACtC;AAED,MAAM,WAAW,sBAAsB;IACrC,gBAAgB,EAAE,uBAAuB,CAAC;IAC1C,aAAa,EAAE,8BAA8B,CAAC;IAC9C,YAAY,EAAE,iBAAiB,CAAC;IAChC,iBAAiB,EAAE,UAAU,CAAC;IAC9B,8BAA8B,EAAE,2BAA2B,CAAC;IAC5D,OAAO,EAAE,+BAA+B,CAAC;IACzC,OAAO,EAAE,+BAA+B,CAAC;IACzC,iCAAiC,EAAE;QACjC,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,OAAO,EAAE,SAAS,2BAA2B,EAAE,CAAC;CACjD;AAoVD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,oCAAoC,GAC1C,iBAAiB,CAAC,sBAAsB,CAAC,CAkG3C"}

package/dist/sensor/exposure-window.js

@@ -0,0 +1,305 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Module boundary and integration notes.
+ * Resolves local capture exposure windows from independent opening and closing boundary schedules. The
+ * returned time basis is seconds from the first opening-boundary phase. This is intentionally not the
+ * existing camera-rotation API's global "exposure start" semantic; a later integration layer must bind
+ * those time bases explicitly. The mechanism identifies whether each boundary is mechanical or
+ * electronic, but does not supply any traversal duration or direction. Every non-simultaneous timing
+ * value and direction is caller-declared with evidence. The first model supports simultaneous
+ * boundaries and uniform-linear single-axis native-sensor scans only. It does not model curtain
+ * acceleration, segmented/nonlinear electronic schedules, flash/flicker, rolling-shutter image
+ * distortion, shutter shock, or EFCS-specific pupil/bokeh behavior.
+ * @see docs/MOTION_AND_SIGNAL.md for equations, coordinate/unit conventions, blockers and support
+ * limits.
+ */
+import { approximationResult } from "../core/calculation-result.js";
+import { parseEvidenceList } from "../core/evidence-provenance.js";
+import { InvalidScientificInputError, requirePositiveInteger } from "../core/validation.js";
+const SHUTTER_MECHANISMS = new Set([
+    "mechanical",
+    "electronic-first-curtain",
+    "electronic"
+]);
+const SCAN_DIRECTIONS = new Set([
+    "top-to-bottom",
+    "bottom-to-top",
+    "left-to-right",
+    "right-to-left"
+]);
+const BOUNDARY_KINDS = new Set([
+    "simultaneous",
+    "uniform-linear-native-scan"
+]);
+function requireRecord(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new InvalidScientificInputError(path + " must be an object.");
+    }
+    return value;
+}
+function requireNonNegativeInteger(name, value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new InvalidScientificInputError(name + " must be a non-negative safe integer.");
+    }
+}
+function requirePositiveFinite(name, value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw new InvalidScientificInputError(name + " must be a finite number greater than zero.");
+    }
+    return value;
+}
+function parseSecondsFact(value, path) {
+    const record = requireRecord(value, path);
+    if (record.unit !== "s") {
+        throw new InvalidScientificInputError(path + '.unit must be "s".');
+    }
+    return {
+        value: requirePositiveFinite(path + ".value", record.value),
+        unit: "s",
+        evidence: parseEvidenceList(record.evidence, path + ".evidence")
+    };
+}
+function parseDirectionFact(value, path) {
+    const record = requireRecord(value, path);
+    if (typeof record.value !== "string" ||
+        !SCAN_DIRECTIONS.has(record.value)) {
+        throw new InvalidScientificInputError(path + ".value is invalid.");
+    }
+    return {
+        value: record.value,
+        evidence: parseEvidenceList(record.evidence, path + ".evidence")
+    };
+}
+function parseBoundarySchedule(value, path) {
+    const record = requireRecord(value, path);
+    if (typeof record.kind !== "string" ||
+        !BOUNDARY_KINDS.has(record.kind)) {
+        throw new InvalidScientificInputError(path + ".kind is invalid.");
+    }
+    if (record.kind === "simultaneous") {
+        if (record.directionNative !== undefined) {
+            throw new InvalidScientificInputError(path + ".directionNative must be omitted for a simultaneous boundary.");
+        }
+        if (record.traversalDurationSeconds !== undefined) {
+            throw new InvalidScientificInputError(path +
+                ".traversalDurationSeconds must be omitted for a simultaneous boundary.");
+        }
+        return { kind: "simultaneous" };
+    }
+    return {
+        kind: "uniform-linear-native-scan",
+        directionNative: parseDirectionFact(record.directionNative, path + ".directionNative"),
+        traversalDurationSeconds: parseSecondsFact(record.traversalDurationSeconds, path + ".traversalDurationSeconds")
+    };
+}
+function validateNativeRaster(raster) {
+    requirePositiveInteger("nativeRaster.pixelWidth", raster.pixelWidth);
+    requirePositiveInteger("nativeRaster.pixelHeight", raster.pixelHeight);
+}
+function fullRect(raster) {
+    return {
+        x: 0,
+        y: 0,
+        width: raster.pixelWidth,
+        height: raster.pixelHeight
+    };
+}
+function validateActiveCaptureRect(rect, raster) {
+    requireNonNegativeInteger("activeCaptureRect.x", rect.x);
+    requireNonNegativeInteger("activeCaptureRect.y", rect.y);
+    requirePositiveInteger("activeCaptureRect.width", rect.width);
+    requirePositiveInteger("activeCaptureRect.height", rect.height);
+    if (rect.x + rect.width > raster.pixelWidth ||
+        rect.y + rect.height > raster.pixelHeight) {
+        throw new InvalidScientificInputError("activeCaptureRect must fit entirely within nativeRaster.");
+    }
+}
+function validateShutterMechanism(value) {
+    if (typeof value !== "string" ||
+        !SHUTTER_MECHANISMS.has(value)) {
+        throw new InvalidScientificInputError("shutterMechanism is invalid.");
+    }
+}
+function validatePointWithinActiveCapture(point, rect, path) {
+    if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+        throw new InvalidScientificInputError(path + " coordinates must be finite.");
+    }
+    if (point.x < rect.x ||
+        point.x > rect.x + rect.width ||
+        point.y < rect.y ||
+        point.y > rect.y + rect.height) {
+        throw new InvalidScientificInputError(path + " must lie within activeCaptureRect edge-coordinate bounds.");
+    }
+}
+function scanVector(direction) {
+    switch (direction) {
+        case "top-to-bottom":
+            return { x: 0, y: 1 };
+        case "bottom-to-top":
+            return { x: 0, y: -1 };
+        case "left-to-right":
+            return { x: 1, y: 0 };
+        case "right-to-left":
+            return { x: -1, y: 0 };
+    }
+}
+function normalizedScanPosition(point, rect, direction) {
+    switch (direction) {
+        case "top-to-bottom":
+            return (point.y - rect.y) / rect.height;
+        case "bottom-to-top":
+            return 1 - (point.y - rect.y) / rect.height;
+        case "left-to-right":
+            return (point.x - rect.x) / rect.width;
+        case "right-to-left":
+            return 1 - (point.x - rect.x) / rect.width;
+    }
+}
+function boundaryPhase(point, rect, schedule) {
+    if (schedule.kind === "simultaneous") {
+        return {
+            normalizedScanPosition: null,
+            phaseOffsetSeconds: 0
+        };
+    }
+    const normalized = normalizedScanPosition(point, rect, schedule.directionNative.value);
+    return {
+        normalizedScanPosition: normalized,
+        phaseOffsetSeconds: normalized * schedule.traversalDurationSeconds.value
+    };
+}
+function resolveBoundaryActuators(mechanism) {
+    switch (mechanism) {
+        case "mechanical":
+            return {
+                opening: "mechanical",
+                closing: "mechanical"
+            };
+        case "electronic-first-curtain":
+            return {
+                opening: "electronic",
+                closing: "mechanical"
+            };
+        case "electronic":
+            return {
+                opening: "electronic",
+                closing: "electronic"
+            };
+    }
+}
+function resolveBoundary(actuator, schedule) {
+    if (schedule.kind === "simultaneous") {
+        return {
+            actuator,
+            schedule: {
+                kind: "simultaneous"
+            }
+        };
+    }
+    return {
+        actuator,
+        schedule: {
+            kind: "uniform-linear-native-scan",
+            directionNative: schedule.directionNative,
+            unitVectorNative: scanVector(schedule.directionNative.value),
+            traversalDurationSeconds: schedule.traversalDurationSeconds
+        }
+    };
+}
+function createWindowSample(point, rect, opening, closing, nominalExposureDurationSeconds) {
+    const openingPhase = boundaryPhase(point, rect, opening);
+    const closingPhase = boundaryPhase(point, rect, closing);
+    const startOffsetSecondsFromOpeningReference = openingPhase.phaseOffsetSeconds;
+    const endOffsetSecondsFromOpeningReference = nominalExposureDurationSeconds + closingPhase.phaseOffsetSeconds;
+    const localExposureDurationSeconds = endOffsetSecondsFromOpeningReference -
+        startOffsetSecondsFromOpeningReference;
+    return {
+        pointNative: { ...point },
+        openingNormalizedScanPosition: openingPhase.normalizedScanPosition,
+        closingNormalizedScanPosition: closingPhase.normalizedScanPosition,
+        startOffsetSecondsFromOpeningReference,
+        endOffsetSecondsFromOpeningReference,
+        localExposureDurationSeconds
+    };
+}
+function activeRectCorners(rect) {
+    return [
+        { x: rect.x, y: rect.y },
+        { x: rect.x + rect.width, y: rect.y },
+        { x: rect.x, y: rect.y + rect.height },
+        {
+            x: rect.x + rect.width,
+            y: rect.y + rect.height
+        }
+    ];
+}
+/**
+ * Resolves local capture exposure windows from independent opening and closing
+ * boundary schedules.
+ *
+ * The returned time basis is seconds from the first opening-boundary phase.
+ * This is intentionally not the existing camera-rotation API's global
+ * "exposure start" semantic; a later integration layer must bind those time
+ * bases explicitly.
+ *
+ * The mechanism identifies whether each boundary is mechanical or electronic,
+ * but does not supply any traversal duration or direction. Every non-simultaneous
+ * timing value and direction is caller-declared with evidence.
+ *
+ * The first model supports simultaneous boundaries and uniform-linear
+ * single-axis native-sensor scans only. It does not model curtain acceleration,
+ * segmented/nonlinear electronic schedules, flash/flicker, rolling-shutter
+ * image distortion, shutter shock, or EFCS-specific pupil/bokeh behavior.
+ */
+export function calculateCaptureExposureWindows(input) {
+    validateNativeRaster(input.nativeRaster);
+    validateShutterMechanism(input.shutterMechanism);
+    const nominalExposureDurationSeconds = parseSecondsFact(input.nominalExposureDurationSeconds, "nominalExposureDurationSeconds");
+    const opening = parseBoundarySchedule(input.opening, "opening");
+    const closing = parseBoundarySchedule(input.closing, "closing");
+    const activeCaptureRect = input.activeCaptureRect ?? fullRect(input.nativeRaster);
+    validateActiveCaptureRect(activeCaptureRect, input.nativeRaster);
+    if (input.samplePointsNative !== undefined &&
+        !Array.isArray(input.samplePointsNative)) {
+        throw new InvalidScientificInputError("samplePointsNative must be an array when supplied.");
+    }
+    const cornerSamples = activeRectCorners(activeCaptureRect).map((point) => createWindowSample(point, activeCaptureRect, opening, closing, nominalExposureDurationSeconds.value));
+    const localDurations = cornerSamples.map((sample) => sample.localExposureDurationSeconds);
+    const minimumLocalExposureDurationSeconds = Math.min(...localDurations);
+    const maximumLocalExposureDurationSeconds = Math.max(...localDurations);
+    if (!Number.isFinite(minimumLocalExposureDurationSeconds) ||
+        minimumLocalExposureDurationSeconds <= 0) {
+        throw new InvalidScientificInputError("The declared opening/closing schedules produce a zero or negative local exposure duration somewhere within activeCaptureRect.");
+    }
+    const samples = (input.samplePointsNative ?? []).map((point, index) => {
+        validatePointWithinActiveCapture(point, activeCaptureRect, "samplePointsNative[" + index + "]");
+        return createWindowSample(point, activeCaptureRect, opening, closing, nominalExposureDurationSeconds.value);
+    });
+    const actuators = resolveBoundaryActuators(input.shutterMechanism);
+    return approximationResult({
+        shutterMechanism: input.shutterMechanism,
+        timeReference: "first-opening-boundary-phase",
+        nativeRaster: { ...input.nativeRaster },
+        activeCaptureRect: { ...activeCaptureRect },
+        nominalExposureDurationSeconds,
+        opening: resolveBoundary(actuators.opening, opening),
+        closing: resolveBoundary(actuators.closing, closing),
+        localExposureDurationRangeSeconds: {
+            minimum: minimumLocalExposureDurationSeconds,
+            maximum: maximumLocalExposureDurationSeconds
+        },
+        samples
+    }, "capture-exposure-window-schedule", "1.0.0", [
+        "Time is reported in seconds from the first opening-boundary phase, not from a universal local exposure-start event.",
+        "Nominal exposure duration, opening traversal, and closing traversal are independent declared quantities.",
+        "Mechanical, electronic-first-curtain, and electronic mechanisms determine boundary actuator categories only; they do not supply timing or direction.",
+        "Uniform-linear scan boundaries are an explicit approximation over continuous effective native-raster coordinates and do not assert one raster row/column equals one physical curtain line, photodiode row, or hardware readout line.",
+        "Opening and closing directions and traversal durations are independent and may produce spatially varying local exposure duration.",
+        "The complete active rectangle is validated using the extrema of the affine boundary schedules, so unsampled invalid corners cannot pass.",
+        "Active-capture timing is caller-declared and is not inferred by scaling full-frame timing from crop dimensions.",
+        "Physical camera orientation and digital output crop/resolution remain downstream of the invariant native timing schedule.",
+        "Sensor readout timing remains a separate contract; this model does not automatically equate a sensor readout phase with an exposure boundary.",
+        "This model does not include curtain acceleration, segmented/nonlinear electronic timing, rolling-shutter image distortion, motion integration, flash/flicker interaction, shutter shock, or EFCS-specific pupil/bokeh behavior."
+    ]);
+}
+//# sourceMappingURL=exposure-window.js.map