@photivra/engine 1.4.0 → 2.0.0

package/dist/stabilization/system.js

@@ -1,22 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Module boundary and integration notes.
- * Validate an untrusted declaration and return the normalized typed contract. Unknown enum values,
- * missing required fields and incompatible scientific data fail at this boundary. Generic
- * stabilization evaluates declared angular disturbance with per-axis response, latency, limits and
- * panning policy. Residual motion feeds the existing temporal mapping; no commercial IBIS/OIS
- * calibration, arbitrary stop rating or inferred coordination is supplied.
- * Validate an untrusted declaration and return the normalized typed contract. Unknown enum values,
- * missing required fields and incompatible scientific data fail at this boundary. Generic
- * stabilization evaluates declared angular disturbance with per-axis response, latency, limits and
- * panning policy. Residual motion feeds the existing temporal mapping; no commercial IBIS/OIS
- * calibration, arbitrary stop rating or inferred coordination is supplied.
- * @see docs/STABILIZATION.md for equations, coordinate/unit conventions, blockers and support limits.
+ * Generic image stabilization: profiles, disturbance trajectories, the stabilized rotation and its
+ * effect on capture timing samples.
+ *
+ * The parsers validate untrusted input and return the normalized typed contract. Unknown enum values,
+ * missing required fields and incompatible scientific data are rejected.
+ *
+ * The generic stabilizer takes a declared angular disturbance (camera shake) and applies a per-axis
+ * response, latency, travel limits and a panning policy. The leftover (residual) motion feeds the
+ * existing temporal mapping. No commercial IBIS (in-body) or OIS (optical) calibration is supplied,
+ * no arbitrary "stops" rating is used, and body/lens coordination is never inferred.
+ * @see docs/STABILIZATION.md for the equations, units, coordinate conventions, known blockers and
+ * support limits.
  */
 import { approximationResult } from "../core/calculation-result.js";
 import { InvalidConfigurationError } from "../core/configuration-error.js";
 import { parseEvidenceList } from "../core/evidence-provenance.js";
 import { InvalidScientificInputError, requirePositiveInteger } from "../core/validation.js";
+import { requireInputKeys, requireInputObject, rejectUnknownFields, rejectUnknownVariantFields } from "../core/record-validation.js";
 export const STABILIZATION_SYSTEM_PROFILE_SCHEMA_VERSION = "0.1.0";
 export const STABILIZATION_DISTURBANCE_TRAJECTORY_VERSION = "0.1.0";
 const AXES = new Set([
@@ -34,12 +35,14 @@ const CAPTURE_KINDS = new Set([
     "still",
     "video"
 ]);
-function requireRecord(value, path) {
+function requireRecord(value, path, allowedKeys) {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value)) {
         throw new InvalidConfigurationError(path + " must be an object.");
     }
+    if (allowedKeys !== null)
+        rejectUnknownFields(value, allowedKeys, path);
     return value;
 }
 function requireNonEmptyString(value, path) {
@@ -98,21 +101,21 @@ function parseLimitations(value, path) {
     return parsed;
 }
 function parseFractionFact(value, path) {
-    const record = requireRecord(value, path);
+    const record = requireRecord(value, path, ["value", "evidence"]);
     return {
         value: requireFraction(record.value, path + ".value"),
         evidence: parseEvidenceList(record.evidence, path + ".evidence")
     };
 }
 function parseNonNegativeFact(value, path) {
-    const record = requireRecord(value, path);
+    const record = requireRecord(value, path, ["value", "evidence"]);
     return {
         value: requireNonNegativeFinite(record.value, path + ".value"),
         evidence: parseEvidenceList(record.evidence, path + ".evidence")
     };
 }
 function parsePositiveFact(value, path) {
-    const record = requireRecord(value, path);
+    const record = requireRecord(value, path, ["value", "evidence"]);
     return {
         value: requirePositiveFinite(record.value, path + ".value"),
         evidence: parseEvidenceList(record.evidence, path + ".evidence")
@@ -126,7 +129,7 @@ function parseAxis(value, path) {
     return value;
 }
 function parseAxisResponse(value, path) {
-    const record = requireRecord(value, path);
+    const record = requireRecord(value, path, ["axis", "correctionGain", "latencySeconds", "maximumCorrectionAngleRad"]);
     return {
         axis: parseAxis(record.axis, path + ".axis"),
         correctionGain: parseFractionFact(record.correctionGain, path +
@@ -139,7 +142,8 @@ function parseAxisResponse(value, path) {
     };
 }
 function parsePanningPolicy(value, path) {
-    const record = requireRecord(value, path);
+    const record = requireRecord(value, path, null);
+    rejectUnknownVariantFields(record, "kind", { none: ["kind"], "declared-axis-bypass": ["kind", "axis", "evidence"] }, path);
     if (record.kind === "none") {
         return {
             kind: "none"
@@ -156,7 +160,7 @@ function parsePanningPolicy(value, path) {
     throw new InvalidConfigurationError(path + ".kind is invalid.");
 }
 function parseCoordinatedAllocation(value, path) {
-    const record = requireRecord(value, path);
+    const record = requireRecord(value, path, ["totalCorrectionAppliedOnce", "bodyFraction", "lensFraction", "evidence"]);
     if (record
         .totalCorrectionAppliedOnce !==
         true) {
@@ -180,19 +184,20 @@ function parseCoordinatedAllocation(value, path) {
     };
 }
 /**
- * Validate an untrusted declaration and return the normalized typed contract. Unknown enum values,
- * missing required fields and incompatible scientific data fail at this boundary.
+ * Validates an untrusted declaration and returns the normalized typed contract. Unknown enum values,
+ * missing required fields and incompatible scientific data are rejected here.
  *
- * Generic stabilization evaluates declared angular disturbance with per-axis response, latency, limits
- * and panning policy. Residual motion feeds the existing temporal mapping; no commercial IBIS/OIS
- * calibration, arbitrary stop rating or inferred coordination is supplied.
- * @param value - unknown. Treated as untrusted data; static typing alone is not validation.
- * @returns StabilizationSystemProfile. Return shape and scientific status are explicit; no calibration is inferred from successful execution.
+ * The generic stabilizer takes a declared angular disturbance (camera shake) and applies a per-axis
+ * response, latency, travel limits and a panning policy. The leftover (residual) motion feeds the
+ * existing temporal mapping. No commercial IBIS (in-body) or OIS (optical) calibration is supplied,
+ * no arbitrary "stops" rating is used, and body/lens coordination is never inferred.
+ * @param value - unknown. Untrusted input; TypeScript types alone are not validation.
+ * @returns StabilizationSystemProfile. The result states its shape and scientific status; a successful call does not imply calibration.
  *
  * @see docs/API_REFERENCE.md for the root export and exact type graph.
  */
 export function parseStabilizationSystemProfile(value) {
-    const record = requireRecord(value, "stabilizationSystemProfile");
+    const record = requireRecord(value, "stabilizationSystemProfile", ["schemaVersion", "profileKind", "scientificStatus", "architecture", "captureKind", "axisResponses", "panningPolicy", "coordinatedAllocation", "profileId", "profileVersion", "evidence", "limitations", "controlTransientModeled", "spontaneousDriftModeled", "cameraTranslationCorrectionModeled", "digitalStabilizationIncluded", "supportPolicyIncluded", "stopRatingUsedAsDynamicResponse"]);
     if (record.schemaVersion !==
         STABILIZATION_SYSTEM_PROFILE_SCHEMA_VERSION) {
         throw new InvalidConfigurationError('stabilizationSystemProfile.schemaVersion must be "' +
@@ -303,7 +308,7 @@ export function parseStabilizationSystemProfile(value) {
     };
 }
 function parseAngularState(value, path) {
-    const record = requireRecord(value, path);
+    const record = requireRecord(value, path, ["pitch", "yaw", "roll"]);
     return {
         pitch: requireFinite(record.pitch, path + ".pitch"),
         yaw: requireFinite(record.yaw, path + ".yaw"),
@@ -311,19 +316,20 @@ function parseAngularState(value, path) {
     };
 }
 /**
- * Validate an untrusted declaration and return the normalized typed contract. Unknown enum values,
- * missing required fields and incompatible scientific data fail at this boundary.
+ * Validates an untrusted declaration and returns the normalized typed contract. Unknown enum values,
+ * missing required fields and incompatible scientific data are rejected here.
  *
- * Generic stabilization evaluates declared angular disturbance with per-axis response, latency, limits
- * and panning policy. Residual motion feeds the existing temporal mapping; no commercial IBIS/OIS
- * calibration, arbitrary stop rating or inferred coordination is supplied.
- * @param value - unknown. Treated as untrusted data; static typing alone is not validation.
- * @returns StabilizationDisturbanceTrajectory. Return shape and scientific status are explicit; no calibration is inferred from successful execution.
+ * The generic stabilizer takes a declared angular disturbance (camera shake) and applies a per-axis
+ * response, latency, travel limits and a panning policy. The leftover (residual) motion feeds the
+ * existing temporal mapping. No commercial IBIS (in-body) or OIS (optical) calibration is supplied,
+ * no arbitrary "stops" rating is used, and body/lens coordination is never inferred.
+ * @param value - unknown. Untrusted input; TypeScript types alone are not validation.
+ * @returns StabilizationDisturbanceTrajectory. The result states its shape and scientific status; a successful call does not imply calibration.
  *
  * @see docs/API_REFERENCE.md for the root export and exact type graph.
  */
 export function parseStabilizationDisturbanceTrajectory(value) {
-    const record = requireRecord(value, "stabilizationDisturbanceTrajectory");
+    const record = requireRecord(value, "stabilizationDisturbanceTrajectory", ["version", "timeReference", "initialAngularDisplacementIsZero", "cameraTranslationIncluded", "subjectMotionIncluded", "supportStateEncoded", "samples", "trajectoryId", "evidence", "limitations"]);
     if (record.version !==
         STABILIZATION_DISTURBANCE_TRAJECTORY_VERSION ||
         record.timeReference !==
@@ -349,7 +355,7 @@ export function parseStabilizationDisturbanceTrajectory(value) {
         const path = "stabilizationDisturbanceTrajectory.samples[" +
             index +
             "]";
-        const sample = requireRecord(entry, path);
+        const sample = requireRecord(entry, path, ["timeSecondsFromCaptureReference", "angularDisplacementRad"]);
         const time = requireNonNegativeFinite(sample
             .timeSecondsFromCaptureReference, path +
             ".timeSecondsFromCaptureReference");
@@ -392,53 +398,84 @@ export function parseStabilizationDisturbanceTrajectory(value) {
         limitations: parseLimitations(record.limitations, "stabilizationDisturbanceTrajectory.limitations")
     };
 }
-function interpolateAxis(trajectory, timeSeconds, axis) {
-    const first = trajectory.samples[0];
-    const last = trajectory.samples[trajectory.samples.length -
-        1];
-    if (timeSeconds <
-        first
-            .timeSecondsFromCaptureReference ||
-        timeSeconds >
-            last
-                .timeSecondsFromCaptureReference) {
+function indexDisturbance(trajectory) {
+    const times = new Float64Array(trajectory.samples.length);
+    for (let index = 0; index < times.length; index += 1) {
+        times[index] =
+            trajectory.samples[index]
+                .timeSecondsFromCaptureReference;
+    }
+    return {
+        samples: trajectory.samples,
+        times
+    };
+}
+/**
+ * Returns the left index of the support segment used for `timeSeconds`. Returns -1 for the final support
+ * time, which uses its stored value. The chosen segment is exactly the one a first-match linear scan
+ * would pick: the smallest `i` with `t[i] <= timeSeconds <= t[i + 1]`. Support times strictly
+ * increase, so a time that equals an interior support time uses the segment on its left.
+ */
+function locateDisturbanceSegment(disturbance, timeSeconds) {
+    const times = disturbance.times;
+    const lastIndex = times.length - 1;
+    if (timeSeconds < times[0] ||
+        timeSeconds > times[lastIndex]) {
         throw new InvalidScientificInputError("Requested stabilization evaluation time lies outside the disturbance trajectory support.");
     }
     if (timeSeconds ===
-        last
-            .timeSecondsFromCaptureReference) {
-        return last
+        times[lastIndex]) {
+        return -1;
+    }
+    // Lower bound: first index whose support time is >= timeSeconds.
+    let low = 0;
+    let high = lastIndex;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (times[middle] >=
+            timeSeconds) {
+            high = middle;
+        }
+        else {
+            low = middle + 1;
+        }
+    }
+    const index = low === 0 ? 0 : low - 1;
+    if (!(timeSeconds >=
+        times[index] &&
+        timeSeconds <=
+            times[index + 1])) {
+        throw new InvalidScientificInputError("Disturbance trajectory interpolation failed.");
+    }
+    return index;
+}
+function interpolateDisturbanceSegment(disturbance, segmentIndex, timeSeconds, axis) {
+    const samples = disturbance.samples;
+    if (segmentIndex < 0) {
+        return samples[samples.length - 1]
             .angularDisplacementRad[axis];
     }
-    for (let index = 0; index <
-        trajectory.samples.length - 1; index += 1) {
-        const left = trajectory.samples[index];
-        const right = trajectory.samples[index + 1];
-        if (timeSeconds >=
+    const left = samples[segmentIndex];
+    const right = samples[segmentIndex + 1];
+    const duration = right
+        .timeSecondsFromCaptureReference -
+        left
+            .timeSecondsFromCaptureReference;
+    const phase = duration === 0
+        ? 0
+        : (timeSeconds -
             left
-                .timeSecondsFromCaptureReference &&
-            timeSeconds <=
-                right
-                    .timeSecondsFromCaptureReference) {
-            const duration = right
-                .timeSecondsFromCaptureReference -
-                left
-                    .timeSecondsFromCaptureReference;
-            const phase = duration === 0
-                ? 0
-                : (timeSeconds -
-                    left
-                        .timeSecondsFromCaptureReference) /
-                    duration;
-            const a = left
-                .angularDisplacementRad[axis];
-            const b = right
-                .angularDisplacementRad[axis];
-            return (a +
-                (b - a) * phase);
-        }
-    }
-    throw new InvalidScientificInputError("Disturbance trajectory interpolation failed.");
+                .timeSecondsFromCaptureReference) /
+            duration;
+    const a = left
+        .angularDisplacementRad[axis];
+    const b = right
+        .angularDisplacementRad[axis];
+    return (a +
+        (b - a) * phase);
+}
+function interpolateAxis(disturbance, timeSeconds, axis) {
+    return interpolateDisturbanceSegment(disturbance, locateDisturbanceSegment(disturbance, timeSeconds), timeSeconds, axis);
 }
 function axisValue(state, axis) {
     return state[axis];
@@ -449,11 +486,20 @@ function setAxisValue(state, axis, value) {
 function clampSymmetric(value, limit) {
     return Math.max(-limit, Math.min(limit, value));
 }
-function evaluateAtTime(disturbance, profile, timeSeconds) {
+/** Built once per calculation. Later entries win, as with a per-evaluation Map. */
+function indexAxisResponses(profile) {
+    return new Map(profile.axisResponses.map((response) => [
+        response.axis,
+        response
+    ]));
+}
+function evaluateAtTime(disturbance, profile, responses, timeSeconds) {
+    // One segment lookup serves all three axes at the same time.
+    const segment = locateDisturbanceSegment(disturbance, timeSeconds);
     const current = {
-        pitch: interpolateAxis(disturbance, timeSeconds, "pitch"),
-        yaw: interpolateAxis(disturbance, timeSeconds, "yaw"),
-        roll: interpolateAxis(disturbance, timeSeconds, "roll")
+        pitch: interpolateDisturbanceSegment(disturbance, segment, timeSeconds, "pitch"),
+        yaw: interpolateDisturbanceSegment(disturbance, segment, timeSeconds, "yaw"),
+        roll: interpolateDisturbanceSegment(disturbance, segment, timeSeconds, "roll")
     };
     const correction = {
         pitch: 0,
@@ -463,10 +509,6 @@ function evaluateAtTime(disturbance, profile, timeSeconds) {
     const residual = {
         ...current
     };
-    const responses = new Map(profile.axisResponses.map((response) => [
-        response.axis,
-        response
-    ]));
     const axes = ["pitch", "yaw", "roll"];
     const resolvedAxes = axes.map((axis) => {
         const response = responses.get(axis);
@@ -539,25 +581,29 @@ function evaluateAtTime(disturbance, profile, timeSeconds) {
     };
 }
 /**
- * Evaluate the declared generic per-axis controller against an explicit angular disturbance trajectory
- * and return residual motion with latency/limit diagnostics.
+ * Runs the declared generic per-axis controller against an explicit angular disturbance trajectory.
+ * Returns the residual motion, with diagnostics for latency and travel limits.
  *
- * Generic stabilization evaluates declared angular disturbance with per-axis response, latency, limits
- * and panning policy. Residual motion feeds the existing temporal mapping; no commercial IBIS/OIS
- * calibration, arbitrary stop rating or inferred coordination is supplied.
- * @param input - CalculateStabilizedRotationTrajectoryInput. See the linked contract for coordinate, unit and profile binding semantics.
- * @returns CalculationResult<StabilizedRotationTrajectory>. Return shape and scientific status are explicit; no calibration is inferred from successful execution.
+ * The generic stabilizer takes a declared angular disturbance (camera shake) and applies a per-axis
+ * response, latency, travel limits and a panning policy. The leftover (residual) motion feeds the
+ * existing temporal mapping. No commercial IBIS (in-body) or OIS (optical) calibration is supplied,
+ * no arbitrary "stops" rating is used, and body/lens coordination is never inferred.
+ * @param input - CalculateStabilizedRotationTrajectoryInput. See that type for coordinates, units and profile binding.
+ * @returns CalculationResult<StabilizedRotationTrajectory>. The result states its shape and scientific status; a successful call does not imply calibration.
  *
  * @see docs/API_REFERENCE.md for the root export and exact type graph.
  */
 export function calculateStabilizedRotationTrajectory(input) {
+    requireInputKeys(input, "calculateStabilizedRotationTrajectory", ["disturbance", "profile", "captureKind"]);
     const disturbance = parseStabilizationDisturbanceTrajectory(input.disturbance);
     const profile = parseStabilizationSystemProfile(input.profile);
     if (input.captureKind !==
         profile.captureKind) {
         throw new InvalidScientificInputError("captureKind must exactly match the stabilization profile captureKind.");
     }
-    const samples = disturbance.samples.map((sample) => evaluateAtTime(disturbance, profile, sample
+    const disturbanceIndex = indexDisturbance(disturbance);
+    const responses = indexAxisResponses(profile);
+    const samples = disturbance.samples.map((sample) => evaluateAtTime(disturbanceIndex, profile, responses, sample
         .timeSecondsFromCaptureReference));
     return approximationResult({
         profileId: profile.profileId,
@@ -586,13 +632,46 @@ export function calculateStabilizedRotationTrajectory(input) {
         "The legacy stabilizationStopsEquivalent approximation remains unchanged."
     ]);
 }
-function localExposureForPoint(timing, point) {
-    const matches = timing.exposureWindows.samples.filter((sample) => sample.pointNative.x ===
+/**
+ * Groups the committed exposure-window samples by native point, once per calculation, and keeps their
+ * order. Map keys compare with SameValueZero, so lookups are filtered again with the original `===`
+ * test: NaN never matches, and +0 matches -0.
+ */
+function indexExposureWindows(timing) {
+    requireInputObject(timing, "timing");
+    requireInputObject(timing.exposureWindows, "timing.exposureWindows");
+    if (!Array.isArray(timing.exposureWindows.samples))
+        throw new InvalidConfigurationError("timing.exposureWindows.samples must be an array.");
+    timing.exposureWindows.samples.forEach((sample, index) => {
+        requireInputObject(sample, "timing.exposureWindows.samples[" + index + "]");
+        requireInputObject(sample.pointNative, "timing.exposureWindows.samples[" + index + "].pointNative");
+    });
+    const byX = new Map();
+    for (const sample of timing.exposureWindows.samples) {
+        let byY = byX.get(sample.pointNative.x);
+        if (byY === undefined) {
+            byY = new Map();
+            byX.set(sample.pointNative.x, byY);
+        }
+        const bucket = byY.get(sample.pointNative.y);
+        if (bucket === undefined) {
+            byY.set(sample.pointNative.y, [sample]);
+        }
+        else {
+            bucket.push(sample);
+        }
+    }
+    return byX;
+}
+function localExposureForPoint(windows, point) {
+    const matches = (windows
+        .get(point.x)
+        ?.get(point.y) ?? []).filter((sample) => sample.pointNative.x ===
         point.x &&
         sample.pointNative.y ===
             point.y);
     if (matches.length !== 1) {
-        throw new InvalidScientificInputError("Each stabilization sample point must match exactly one committed #12 exposure-window sample point.");
+        throw new InvalidScientificInputError("Each stabilization sample point must match exactly one committed exposure-window sample point.");
     }
     const match = matches[0];
     return {
@@ -605,18 +684,21 @@ function localExposureForPoint(timing, point) {
     };
 }
 /**
- * Feed the residual stabilized rotation into the existing local-exposure temporal mapping without
- * changing shutter timing or inventing a blur radius.
+ * Feeds the residual stabilized rotation into the existing local-exposure temporal mapping. Shutter
+ * timing is not changed, and no blur radius is invented.
  *
- * Generic stabilization evaluates declared angular disturbance with per-axis response, latency, limits
- * and panning policy. Residual motion feeds the existing temporal mapping; no commercial IBIS/OIS
- * calibration, arbitrary stop rating or inferred coordination is supplied.
- * @param input - CalculateStabilizedCaptureTemporalSamplesInput. See the linked contract for coordinate, unit and profile binding semantics.
- * @returns CalculationResult<StabilizedCaptureTemporalSamples>. Return shape and scientific status are explicit; no calibration is inferred from successful execution.
+ * The generic stabilizer takes a declared angular disturbance (camera shake) and applies a per-axis
+ * response, latency, travel limits and a panning policy. The leftover (residual) motion feeds the
+ * existing temporal mapping. No commercial IBIS (in-body) or OIS (optical) calibration is supplied,
+ * no arbitrary "stops" rating is used, and body/lens coordination is never inferred.
+ * @param input - CalculateStabilizedCaptureTemporalSamplesInput. See that type for coordinates, units and profile binding.
+ * @returns CalculationResult<StabilizedCaptureTemporalSamples>. The result states its shape and scientific status; a successful call does not imply calibration.
  *
  * @see docs/API_REFERENCE.md for the root export and exact type graph.
  */
 export function calculateStabilizedCaptureTemporalSamples(input) {
+    requireInputKeys(input, "calculateStabilizedCaptureTemporalSamples", ["disturbance", "profile", "captureKind", "timing", "samplePointsNative", "temporalSampleCount"]);
+    requireInputObject(input.timing, "timing");
     const disturbance = parseStabilizationDisturbanceTrajectory(input.disturbance);
     const profile = parseStabilizationSystemProfile(input.profile);
     if (input.captureKind !==
@@ -627,15 +709,21 @@ export function calculateStabilizedCaptureTemporalSamples(input) {
     if (!Array.isArray(input.samplePointsNative) ||
         input.samplePointsNative.length ===
             0) {
-        throw new InvalidScientificInputError("samplePointsNative must be a non-empty array.");
+        throw new InvalidConfigurationError("samplePointsNative must be a non-empty array.");
     }
+    input.samplePointsNative.forEach((point, index) => requireInputObject(point, "samplePointsNative[" + index + "]"));
     const totalNodeCount = input.temporalSampleCount *
         input.samplePointsNative.length;
     if (!Number.isSafeInteger(totalNodeCount)) {
         throw new InvalidScientificInputError("temporalSampleCount × samplePointsNative.length must remain a safe integer.");
     }
+    const disturbanceIndex = indexDisturbance(disturbance);
+    const responses = indexAxisResponses(profile);
+    let exposureWindowIndex;
     const points = input.samplePointsNative.map((point) => {
-        const exposure = localExposureForPoint(input.timing, point);
+        exposureWindowIndex ??=
+            indexExposureWindows(input.timing);
+        const exposure = localExposureForPoint(exposureWindowIndex, point);
         const normalizedTimeWeight = 1 /
             input.temporalSampleCount;
         const timeMeasureSeconds = exposure.duration /
@@ -655,7 +743,7 @@ export function calculateStabilizedCaptureTemporalSamples(input) {
                 captureTimeSecondsFromReference: captureTime,
                 normalizedTimeWeight,
                 timeMeasureSeconds,
-                stabilization: evaluateAtTime(disturbance, profile, captureTime)
+                stabilization: evaluateAtTime(disturbanceIndex, profile, responses, captureTime)
             };
         });
         return {
@@ -686,7 +774,7 @@ export function calculateStabilizedCaptureTemporalSamples(input) {
         translationCorrectionModeled: false,
         digitalStabilizationApplied: false
     }, "capture-local-stabilization-temporal-sampling", "1.0.0", [
-        "Stabilization is evaluated at deterministic midpoint nodes inside each authoritative #12 local exposure window.",
+        "Stabilization is evaluated at deterministic midpoint nodes inside each authoritative local exposure window of the exposure-window model.",
         "Sensor data-readout timing is not substituted for exposure timing.",
         "The result is rotational disturbance/correction/residual state only; it does not itself calculate image-plane mapping, radiance, blur, PSF or output pixels.",
         "Translation/parallax, subject motion, shutter shock, support vibration sources and digital stabilization remain separate domains."