@photivra/engine 1.4.0 → 2.0.0

package/dist/color/white-balance.d.ts

@@ -1,4 +1,6 @@
 import { type EvidenceBackedFact, type EvidenceProvenance } from "../core/evidence-provenance.js";
+import { type PlanckianLocusModel, type WhiteLocus } from "./illuminants.js";
+import { type CieXyChromaticity, type ColorMatrix3x3 } from "./colorimetry-math.js";
 export declare const WHITE_BALANCE_PROFILE_SCHEMA_VERSION: "0.1.0";
 export declare const WHITE_BALANCE_STATE_VERSION: "0.1.0";
 export declare const COLOR_TEMPERATURE_WHITE_BALANCE_INTENT_VERSION: "0.1.0";
@@ -21,9 +23,9 @@ export interface WhiteBalanceAwbPolicy {
     policyId: string;
     intent: WhiteBalanceAwbIntent;
     /**
-     * Fraction of a gray-world neutralizing correction applied in logarithmic
-     * gain space. 1 is full neutral-priority correction; lower values preserve
-     * more of the observed cast.
+     * How much of a grey-world neutralizing correction to apply, measured in
+     * logarithmic gain space. 1 applies the full correction (neutral priority).
+     * Lower values keep more of the observed colour cast.
      */
     correctionStrength: EvidenceBackedFact<number>;
     limitations?: readonly string[];
@@ -56,7 +58,7 @@ export interface ResolvedWhiteBalanceState {
     version: typeof WHITE_BALANCE_STATE_VERSION;
     stateId: string;
     inputDomain: WhiteBalanceInputDomain;
-    source: "preset" | "manual-gains" | "custom-measurement" | "auto-white-balance";
+    source: "preset" | "manual-gains" | "custom-measurement" | "auto-white-balance" | "color-temperature";
     channelGains: WhiteBalanceChannelGains;
     locked: boolean;
     sourceProfile?: {
@@ -79,6 +81,8 @@ export interface ResolvedWhiteBalanceState {
             blue: number;
         };
     };
+    /** Present for `color-temperature` states: the declared CCT/tint and its camera neutral. */
+    colorTemperature?: ResolvedColorTemperatureWhiteBalance;
     sourceStateId?: string;
     trueIlluminantMetadataUsed: false;
     sceneIlluminationModified: false;
@@ -96,6 +100,37 @@ export interface ColorTemperatureWhiteBalanceIntent {
     requiresCameraProfileColorimetry: true;
     sceneIlluminationModified: false;
 }
+/** Locus/tint interpretation and camera neutral behind a Kelvin + tint WB state. */
+export interface ResolvedColorTemperatureWhiteBalance {
+    intentId: string;
+    colorTemperatureKelvin: number;
+    tint: number;
+    whiteLocus: WhiteLocus;
+    tintInterpretation: "duv-cie-1960-uv";
+    planckianLocusModel: "planck-analytic-cmf" | "planck-integration";
+    /** CIE 1931 xy of the declared white (CCT + Duv). */
+    adoptedWhiteChromaticity: CieXyChromaticity;
+    /** Pre-WB camera response to that white (XYZ with Y = 1 through xyzToCameraRgb). */
+    cameraNeutralRgb: WhiteBalanceChannelGains;
+}
+/** Camera colour model used to turn a declared white into channel gains. */
+export interface ColorTemperatureWhiteBalanceCameraModel {
+    profileId: string;
+    profileVersion: string;
+    /** Row-major CIE XYZ (white Y = 1) → relative pre-WB camera-linear RGB. */
+    xyzToCameraRgb: ColorMatrix3x3;
+}
+export interface ResolveColorTemperatureWhiteBalanceInput {
+    stateId: string;
+    intent: ColorTemperatureWhiteBalanceIntent;
+    /** Locus whose temperature defines the white: Planckian or CIE daylight. */
+    whiteLocus: WhiteLocus;
+    /** Tint is read as Duv in the CIE 1960 UCS (positive = above the Planckian locus, greenish). */
+    tintInterpretation: "duv-cie-1960-uv";
+    /** Defaults to Planck's law integrated against the engine's analytic CIE 1931 CMFs (`planck-analytic-cmf`). */
+    planckianLocus?: PlanckianLocusModel;
+    camera: ColorTemperatureWhiteBalanceCameraModel;
+}
 export interface ResolvePresetWhiteBalanceInput {
     stateId: string;
     profile: WhiteBalanceProfile;
@@ -127,21 +162,34 @@ export interface CreateLockedWhiteBalanceStateInput {
 /**
  * Parses generic WB presets and AWB policies.
  *
- * Preset gains and AWB correction strength are profile-owned. Labels are not
- * treated as universal Kelvin aliases or manufacturer-specific behavior.
+ * The profile defines preset gains and AWB correction strength. A label is not
+ * treated as a universal Kelvin value or as any manufacturer's behaviour.
  */
 export declare function parseWhiteBalanceProfile(value: unknown): WhiteBalanceProfile;
-/** Resolves a profile-owned WB preset without universal label/Kelvin rules. */
+/** Resolves a WB preset defined by the profile. No universal label-to-Kelvin rule is applied. */
 export declare function resolvePresetWhiteBalance(input: ResolvePresetWhiteBalanceInput): ResolvedWhiteBalanceState;
 /** Resolves explicit manual camera-linear channel gains. */
 export declare function resolveManualWhiteBalance(input: ResolveManualWhiteBalanceInput): ResolvedWhiteBalanceState;
 /**
  * Records independent color-temperature and tint intent.
  *
- * No channel gains are fabricated here; mapping CCT+tint into a camera's
- * channel/color space belongs to a profile/colorimetry contract.
+ * No channel gains are fabricated here; use
+ * `resolveColorTemperatureWhiteBalance()` with an explicit camera colour model to
+ * resolve gains.
  */
 export declare function createColorTemperatureWhiteBalanceIntent(input: CreateColorTemperatureWhiteBalanceIntentInput): ColorTemperatureWhiteBalanceIntent;
+/**
+ * Resolves a Kelvin + tint WB intent into camera channel gains, for an explicit camera
+ * colour model:
+ * - white xy = locus(CCT), offset by Duv = tint along the Planckian-locus normal in CIE 1960 uv;
+ * - camera neutral n = M_XYZ→camera · XYZ(white, Y = 1);
+ * - gains = (n_G/n_R, 1, n_G/n_B).
+ * A neutral surface lit by light of exactly that chromaticity then renders with equal channels.
+ * The CCT and tint are the white the photographer declares, not a measured scene illuminant.
+ * Accuracy is limited by the camera matrix (exact only under the Luther–Ives condition) and by
+ * the locus model.
+ */
+export declare function resolveColorTemperatureWhiteBalance(input: ResolveColorTemperatureWhiteBalanceInput): ResolvedWhiteBalanceState;
 /**
  * Resolves a user-declared neutral/gray custom-WB measurement.
  *
@@ -152,24 +200,25 @@ export declare function resolveCustomWhiteBalance(input: ResolveCustomWhiteBalan
 /**
  * Estimates one global AWB state from declared pre-WB camera-linear samples.
  *
- * It intentionally does not accept true illuminant metadata. A gray-world
- * neutralizing estimate is softened by the profile's correctionStrength so
- * different generic AWB priorities can preserve different amounts of cast.
+ * It deliberately does not accept metadata about the true illuminant. A
+ * grey-world neutralizing estimate is softened by the profile's
+ * correctionStrength, so different generic AWB priorities can keep different
+ * amounts of colour cast.
  */
 export declare function estimateAutoWhiteBalance(input: EstimateAutoWhiteBalanceInput): ResolvedWhiteBalanceState;
 /**
  * Freezes a resolved WB state under a new stable identity.
  *
- * Locking changes neither the scene nor the gains; later AWB estimates may
- * differ while this locked state remains unchanged.
+ * Locking changes neither the scene nor the gains. Later AWB estimates may
+ * differ, but this locked state stays the same.
  */
 export declare function createLockedWhiteBalanceState(input: CreateLockedWhiteBalanceStateInput): ResolvedWhiteBalanceState;
 /**
- * Parses a committed resolved white-balance state from an untrusted JSON
- * boundary without re-estimating WB.
+ * Parses a committed, resolved white-balance state from untrusted JSON,
+ * without estimating WB again.
  *
- * This is intentionally a state parser, not an AWB estimator. It preserves the
- * resolved gains/policy/measurement identity that a capture committed earlier.
+ * This is deliberately a state parser, not an AWB estimator. It keeps the
+ * resolved gains, policy and measurement identity that a capture committed
+ * earlier.
  */
 export declare function parseResolvedWhiteBalanceState(value: unknown): ResolvedWhiteBalanceState;
-//# sourceMappingURL=white-balance.d.ts.map

package/dist/color/white-balance.js

@@ -1,23 +1,30 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Module boundary and integration notes.
- * Parses generic WB presets and AWB policies. Preset gains and AWB correction strength are
- * profile-owned. Labels are not treated as universal Kelvin aliases or manufacturer-specific behavior.
- * Resolves a profile-owned WB preset without universal label/Kelvin rules.
- * @see docs/CAPTURE_COLOR.md for equations, coordinate/unit conventions, blockers and support limits.
+ * White balance (WB): generic presets, manual gains, colour temperature and tint, custom (grey-card)
+ * WB, auto white balance (AWB), WB lock, and parsing of a committed WB state.
+ *
+ * The profile defines preset gains and AWB correction strength. A label such as "Daylight" is not
+ * treated as a universal Kelvin value or as any manufacturer's behaviour.
+ * @see docs/CAPTURE_COLOR.md for the equations, units, coordinate conventions, known blockers and
+ * support limits.
  */
 import { InvalidConfigurationError } from "../core/configuration-error.js";
 import { parseEvidenceList } from "../core/evidence-provenance.js";
 import { InvalidScientificInputError } from "../core/validation.js";
+import { requireInputObject, requireInputKeys, rejectUnknownFields } from "../core/record-validation.js";
+import { calculateChromaticityFromCorrelatedColorTemperature } from "./illuminants.js";
+import { multiplyMatrixVector, parseMatrix3x3, xyzOfChromaticity } from "./colorimetry-math.js";
 export const WHITE_BALANCE_PROFILE_SCHEMA_VERSION = "0.1.0";
 export const WHITE_BALANCE_STATE_VERSION = "0.1.0";
 export const COLOR_TEMPERATURE_WHITE_BALANCE_INTENT_VERSION = "0.1.0";
-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) {
@@ -47,7 +54,7 @@ function requireFraction(value, path) {
     return parsed;
 }
 function parseChannelGains(value, path) {
-    const record = requireRecord(value, path);
+    const record = requireRecord(value, path, ["red", "green", "blue"]);
     return {
         red: requirePositiveFinite(record.red, path + ".red"),
         green: requirePositiveFinite(record.green, path + ".green"),
@@ -68,8 +75,8 @@ function parseOptionalLimitations(value, path) {
     return value === undefined ? undefined : parseLimitations(value, path);
 }
 function parsePreset(value, path) {
-    const record = requireRecord(value, path);
-    const gainsFact = requireRecord(record.channelGains, path + ".channelGains");
+    const record = requireRecord(value, path, ["channelGains", "limitations", "presetId", "label", "nominalColorTemperatureKelvin", "nominalTint"]);
+    const gainsFact = requireRecord(record.channelGains, path + ".channelGains", ["value", "evidence"]);
     const limitations = parseOptionalLimitations(record.limitations, path + ".limitations");
     return {
         presetId: requireNonEmptyString(record.presetId, path + ".presetId"),
@@ -104,8 +111,8 @@ function parseAwbIntent(value, path) {
     return value;
 }
 function parseAwbPolicy(value, path) {
-    const record = requireRecord(value, path);
-    const strengthFact = requireRecord(record.correctionStrength, path + ".correctionStrength");
+    const record = requireRecord(value, path, ["correctionStrength", "limitations", "policyId", "intent"]);
+    const strengthFact = requireRecord(record.correctionStrength, path + ".correctionStrength", ["value", "evidence"]);
     const limitations = parseOptionalLimitations(record.limitations, path + ".limitations");
     return {
         policyId: requireNonEmptyString(record.policyId, path + ".policyId"),
@@ -120,11 +127,11 @@ function parseAwbPolicy(value, path) {
 /**
  * Parses generic WB presets and AWB policies.
  *
- * Preset gains and AWB correction strength are profile-owned. Labels are not
- * treated as universal Kelvin aliases or manufacturer-specific behavior.
+ * The profile defines preset gains and AWB correction strength. A label is not
+ * treated as a universal Kelvin value or as any manufacturer's behaviour.
  */
 export function parseWhiteBalanceProfile(value) {
-    const record = requireRecord(value, "whiteBalanceProfile");
+    const record = requireRecord(value, "whiteBalanceProfile", ["schemaVersion", "scientificStatus", "inputDomain", "presets", "awbPolicies", "profileId", "profileVersion", "evidence", "limitations"]);
     if (record.schemaVersion !== WHITE_BALANCE_PROFILE_SCHEMA_VERSION) {
         throw new InvalidConfigurationError('whiteBalanceProfile.schemaVersion must be "' +
             WHITE_BALANCE_PROFILE_SCHEMA_VERSION +
@@ -166,7 +173,7 @@ export function parseWhiteBalanceProfile(value) {
 }
 function requireScientificNonEmptyString(value, path) {
     if (typeof value !== "string" || value.trim().length === 0) {
-        throw new InvalidScientificInputError(path + " must be a non-empty string.");
+        throw new InvalidConfigurationError(path + " must be a non-empty string.");
     }
     return value.trim();
 }
@@ -208,6 +215,15 @@ function immutableState(state) {
         ...(state.awbPolicy === undefined
             ? {}
             : { awbPolicy: Object.freeze({ ...state.awbPolicy }) }),
+        ...(state.colorTemperature === undefined
+            ? {}
+            : {
+                colorTemperature: Object.freeze({
+                    ...state.colorTemperature,
+                    adoptedWhiteChromaticity: Object.freeze({ ...state.colorTemperature.adoptedWhiteChromaticity }),
+                    cameraNeutralRgb: Object.freeze({ ...state.colorTemperature.cameraNeutralRgb })
+                })
+            }),
         ...(state.measurement === undefined
             ? {}
             : {
@@ -236,8 +252,9 @@ function stateBase(stateId, source, gains, limitations) {
         limitations: [...limitations]
     };
 }
-/** Resolves a profile-owned WB preset without universal label/Kelvin rules. */
+/** Resolves a WB preset defined by the profile. No universal label-to-Kelvin rule is applied. */
 export function resolvePresetWhiteBalance(input) {
+    requireInputKeys(input, "resolvePresetWhiteBalance", ["stateId", "profile", "presetId"]);
     const profile = parseWhiteBalanceProfile(input.profile);
     const presetId = requireScientificNonEmptyString(input.presetId, "presetId");
     const preset = profile.presets.find((entry) => entry.presetId === presetId);
@@ -258,6 +275,7 @@ export function resolvePresetWhiteBalance(input) {
 }
 /** Resolves explicit manual camera-linear channel gains. */
 export function resolveManualWhiteBalance(input) {
+    requireInputKeys(input, "resolveManualWhiteBalance", ["stateId", "channelGains"]);
     return immutableState(stateBase(input.stateId, "manual-gains", input.channelGains, [
         "Manual gains are caller-selected WB intent, not a measured physical illuminant."
     ]));
@@ -265,10 +283,12 @@ export function resolveManualWhiteBalance(input) {
 /**
  * Records independent color-temperature and tint intent.
  *
- * No channel gains are fabricated here; mapping CCT+tint into a camera's
- * channel/color space belongs to a profile/colorimetry contract.
+ * No channel gains are fabricated here; use
+ * `resolveColorTemperatureWhiteBalance()` with an explicit camera colour model to
+ * resolve gains.
  */
 export function createColorTemperatureWhiteBalanceIntent(input) {
+    requireInputKeys(input, "createColorTemperatureWhiteBalanceIntent", ["intentId", "colorTemperatureKelvin", "tint"]);
     return Object.freeze({
         version: COLOR_TEMPERATURE_WHITE_BALANCE_INTENT_VERSION,
         intentId: requireScientificNonEmptyString(input.intentId, "intentId"),
@@ -279,13 +299,78 @@ export function createColorTemperatureWhiteBalanceIntent(input) {
         sceneIlluminationModified: false
     });
 }
+/**
+ * Resolves a Kelvin + tint WB intent into camera channel gains, for an explicit camera
+ * colour model:
+ * - white xy = locus(CCT), offset by Duv = tint along the Planckian-locus normal in CIE 1960 uv;
+ * - camera neutral n = M_XYZ→camera · XYZ(white, Y = 1);
+ * - gains = (n_G/n_R, 1, n_G/n_B).
+ * A neutral surface lit by light of exactly that chromaticity then renders with equal channels.
+ * The CCT and tint are the white the photographer declares, not a measured scene illuminant.
+ * Accuracy is limited by the camera matrix (exact only under the Luther–Ives condition) and by
+ * the locus model.
+ */
+export function resolveColorTemperatureWhiteBalance(input) {
+    requireInputKeys(input, "resolveColorTemperatureWhiteBalance", ["stateId", "intent", "whiteLocus", "tintInterpretation", "planckianLocus", "camera"]);
+    const intent = input.intent;
+    if (typeof intent !== "object" ||
+        intent === null ||
+        intent.version !== COLOR_TEMPERATURE_WHITE_BALANCE_INTENT_VERSION) {
+        throw new InvalidConfigurationError("intent must be a color-temperature WB intent of version " +
+            COLOR_TEMPERATURE_WHITE_BALANCE_INTENT_VERSION +
+            ".");
+    }
+    const intentId = requireScientificNonEmptyString(intent.intentId, "intent.intentId");
+    const kelvin = requireScientificPositiveFinite(intent.colorTemperatureKelvin, "intent.colorTemperatureKelvin");
+    const tint = requireScientificFinite(intent.tint, "intent.tint");
+    if (input.tintInterpretation !== "duv-cie-1960-uv") {
+        throw new InvalidConfigurationError('tintInterpretation must be "duv-cie-1960-uv".');
+    }
+    const camera = input.camera;
+    if (typeof camera !== "object" || camera === null) {
+        throw new InvalidConfigurationError("camera must be an object.");
+    }
+    const profileId = requireScientificNonEmptyString(camera.profileId, "camera.profileId");
+    const profileVersion = requireScientificNonEmptyString(camera.profileVersion, "camera.profileVersion");
+    const matrix = parseMatrix3x3(camera.xyzToCameraRgb, "camera.xyzToCameraRgb");
+    const locus = input.planckianLocus ?? { kind: "planck-analytic-cmf" };
+    const white = calculateChromaticityFromCorrelatedColorTemperature({
+        correlatedColorTemperatureKelvin: kelvin,
+        duv: tint,
+        whiteLocus: input.whiteLocus,
+        locus
+    }).value;
+    const xyz = xyzOfChromaticity(white);
+    const [red, green, blue] = multiplyMatrixVector(matrix, [xyz.x, xyz.y, xyz.z]);
+    if (!(red > 0) || !(green > 0) || !(blue > 0)) {
+        throw new InvalidScientificInputError("The camera response to the declared white must be positive in every channel.");
+    }
+    return immutableState({
+        ...stateBase(input.stateId, "color-temperature", { red: green / red, green: 1, blue: green / blue }, [
+            "Kelvin/tint gains neutralize the declared white through the supplied camera matrix; they do not identify the scene illuminant.",
+            "Tint is Duv in CIE 1960 uv; accuracy is bounded by the camera matrix and the locus model."
+        ]),
+        sourceProfile: { profileId, profileVersion },
+        colorTemperature: {
+            intentId,
+            colorTemperatureKelvin: kelvin,
+            tint,
+            whiteLocus: input.whiteLocus,
+            tintInterpretation: "duv-cie-1960-uv",
+            planckianLocusModel: locus.kind,
+            adoptedWhiteChromaticity: { x: white.x, y: white.y },
+            cameraNeutralRgb: { red, green, blue }
+        }
+    });
+}
 function reduceSampleSet(sampleSet, clippedPolicy) {
+    requireInputObject(sampleSet, "sampleSet input");
     if (sampleSet.inputDomain !== "relative-pre-wb-camera-linear-rgb") {
-        throw new InvalidScientificInputError('sampleSet.inputDomain must be "relative-pre-wb-camera-linear-rgb".');
+        throw new InvalidConfigurationError('sampleSet.inputDomain must be "relative-pre-wb-camera-linear-rgb".');
     }
     const imageStateId = requireScientificNonEmptyString(sampleSet.imageStateId, "sampleSet.imageStateId");
     if (!Array.isArray(sampleSet.samples) || sampleSet.samples.length === 0) {
-        throw new InvalidScientificInputError("sampleSet.samples must be a non-empty array.");
+        throw new InvalidConfigurationError("sampleSet.samples must be a non-empty array.");
     }
     let weightSum = 0;
     let redSum = 0;
@@ -350,6 +435,7 @@ function neutralizingGains(mean) {
  * claim the selected object is spectrally neutral in the real scene.
  */
 export function resolveCustomWhiteBalance(input) {
+    requireInputKeys(input, "resolveCustomWhiteBalance", ["stateId", "sampleSet"]);
     const reduced = reduceSampleSet(input.sampleSet, "reject-any");
     return immutableState({
         ...stateBase(input.stateId, "custom-measurement", neutralizingGains(reduced.weightedMean), [
@@ -367,11 +453,13 @@ export function resolveCustomWhiteBalance(input) {
 /**
  * Estimates one global AWB state from declared pre-WB camera-linear samples.
  *
- * It intentionally does not accept true illuminant metadata. A gray-world
- * neutralizing estimate is softened by the profile's correctionStrength so
- * different generic AWB priorities can preserve different amounts of cast.
+ * It deliberately does not accept metadata about the true illuminant. A
+ * grey-world neutralizing estimate is softened by the profile's
+ * correctionStrength, so different generic AWB priorities can keep different
+ * amounts of colour cast.
  */
 export function estimateAutoWhiteBalance(input) {
+    requireInputKeys(input, "estimateAutoWhiteBalance", ["stateId", "profile", "policyId", "sampleSet"]);
     const profile = parseWhiteBalanceProfile(input.profile);
     const policyId = requireScientificNonEmptyString(input.policyId, "policyId");
     const policy = profile.awbPolicies.find((entry) => entry.policyId === policyId);
@@ -413,10 +501,11 @@ export function estimateAutoWhiteBalance(input) {
 /**
  * Freezes a resolved WB state under a new stable identity.
  *
- * Locking changes neither the scene nor the gains; later AWB estimates may
- * differ while this locked state remains unchanged.
+ * Locking changes neither the scene nor the gains. Later AWB estimates may
+ * differ, but this locked state stays the same.
  */
 export function createLockedWhiteBalanceState(input) {
+    requireInputKeys(input, "createLockedWhiteBalanceState", ["stateId", "sourceState"]);
     const stateId = requireScientificNonEmptyString(input.stateId, "stateId");
     const source = input.sourceState;
     return immutableState({
@@ -444,9 +533,9 @@ function requirePositiveSafeInteger(value, path) {
     return parsed;
 }
 function parseResolvedWhiteBalanceMeasurement(value, path) {
-    const record = requireRecord(value, path);
+    const record = requireRecord(value, path, ["weightedMeanPreWbSignal", "imageStateId", "usableSampleCount", "rejectedClippedSampleCount"]);
     const mean = requireRecord(record.weightedMeanPreWbSignal, path +
-        ".weightedMeanPreWbSignal");
+        ".weightedMeanPreWbSignal", ["red", "green", "blue"]);
     return {
         imageStateId: requireNonEmptyString(record.imageStateId, path + ".imageStateId"),
         usableSampleCount: requirePositiveSafeInteger(record.usableSampleCount, path +
@@ -464,15 +553,43 @@ function parseResolvedWhiteBalanceMeasurement(value, path) {
         }
     };
 }
+function parseResolvedColorTemperature(value, path) {
+    const record = requireRecord(value, path, ["whiteLocus", "tintInterpretation", "planckianLocusModel", "adoptedWhiteChromaticity", "intentId", "colorTemperatureKelvin", "tint", "cameraNeutralRgb"]);
+    if (record.whiteLocus !== "planckian" && record.whiteLocus !== "cie-daylight") {
+        throw new InvalidConfigurationError(path + ".whiteLocus is invalid.");
+    }
+    if (record.tintInterpretation !== "duv-cie-1960-uv") {
+        throw new InvalidConfigurationError(path + ".tintInterpretation is invalid.");
+    }
+    if (record.planckianLocusModel !== "planck-analytic-cmf" &&
+        record.planckianLocusModel !== "planck-integration") {
+        throw new InvalidConfigurationError(path + ".planckianLocusModel is invalid.");
+    }
+    const white = requireRecord(record.adoptedWhiteChromaticity, path + ".adoptedWhiteChromaticity", ["x", "y"]);
+    return {
+        intentId: requireNonEmptyString(record.intentId, path + ".intentId"),
+        colorTemperatureKelvin: requirePositiveFinite(record.colorTemperatureKelvin, path + ".colorTemperatureKelvin"),
+        tint: requireFinite(record.tint, path + ".tint"),
+        whiteLocus: record.whiteLocus,
+        tintInterpretation: "duv-cie-1960-uv",
+        planckianLocusModel: record.planckianLocusModel,
+        adoptedWhiteChromaticity: {
+            x: requirePositiveFinite(white.x, path + ".adoptedWhiteChromaticity.x"),
+            y: requirePositiveFinite(white.y, path + ".adoptedWhiteChromaticity.y")
+        },
+        cameraNeutralRgb: parseChannelGains(record.cameraNeutralRgb, path + ".cameraNeutralRgb")
+    };
+}
 /**
- * Parses a committed resolved white-balance state from an untrusted JSON
- * boundary without re-estimating WB.
+ * Parses a committed, resolved white-balance state from untrusted JSON,
+ * without estimating WB again.
  *
- * This is intentionally a state parser, not an AWB estimator. It preserves the
- * resolved gains/policy/measurement identity that a capture committed earlier.
+ * This is deliberately a state parser, not an AWB estimator. It keeps the
+ * resolved gains, policy and measurement identity that a capture committed
+ * earlier.
  */
 export function parseResolvedWhiteBalanceState(value) {
-    const record = requireRecord(value, "resolvedWhiteBalanceState");
+    const record = requireRecord(value, "resolvedWhiteBalanceState", ["version", "inputDomain", "source", "locked", "sourceProfile", "awbPolicy", "measurement", "colorTemperature", "presetId", "sourceStateId", "stateId", "channelGains", "limitations", "trueIlluminantMetadataUsed", "sceneIlluminationModified", "rawCaptureDestructivelyModified", "physicalExposureModified", "focusModified"]);
     if (record.version !==
         WHITE_BALANCE_STATE_VERSION) {
         throw new InvalidConfigurationError('resolvedWhiteBalanceState.version must be "' +
@@ -489,7 +606,9 @@ export function parseResolvedWhiteBalanceState(value) {
         record.source !==
             "custom-measurement" &&
         record.source !==
-            "auto-white-balance") {
+            "auto-white-balance" &&
+        record.source !==
+            "color-temperature") {
         throw new InvalidConfigurationError("resolvedWhiteBalanceState.source is invalid.");
     }
     if (typeof record.locked !==
@@ -512,7 +631,7 @@ export function parseResolvedWhiteBalanceState(value) {
     const sourceProfile = record.sourceProfile === undefined
         ? undefined
         : (() => {
-            const profile = requireRecord(record.sourceProfile, "resolvedWhiteBalanceState.sourceProfile");
+            const profile = requireRecord(record.sourceProfile, "resolvedWhiteBalanceState.sourceProfile", ["profileId", "profileVersion"]);
             return {
                 profileId: requireNonEmptyString(profile.profileId, "resolvedWhiteBalanceState.sourceProfile.profileId"),
                 profileVersion: requireNonEmptyString(profile.profileVersion, "resolvedWhiteBalanceState.sourceProfile.profileVersion")
@@ -521,7 +640,7 @@ export function parseResolvedWhiteBalanceState(value) {
     const awbPolicy = record.awbPolicy === undefined
         ? undefined
         : (() => {
-            const policy = requireRecord(record.awbPolicy, "resolvedWhiteBalanceState.awbPolicy");
+            const policy = requireRecord(record.awbPolicy, "resolvedWhiteBalanceState.awbPolicy", ["policyId", "intent", "correctionStrength"]);
             return {
                 policyId: requireNonEmptyString(policy.policyId, "resolvedWhiteBalanceState.awbPolicy.policyId"),
                 intent: parseAwbIntent(policy.intent, "resolvedWhiteBalanceState.awbPolicy.intent"),
@@ -531,6 +650,9 @@ export function parseResolvedWhiteBalanceState(value) {
     const measurement = record.measurement === undefined
         ? undefined
         : parseResolvedWhiteBalanceMeasurement(record.measurement, "resolvedWhiteBalanceState.measurement");
+    const colorTemperature = record.colorTemperature === undefined
+        ? undefined
+        : parseResolvedColorTemperature(record.colorTemperature, "resolvedWhiteBalanceState.colorTemperature");
     const presetId = record.presetId === undefined
         ? undefined
         : requireNonEmptyString(record.presetId, "resolvedWhiteBalanceState.presetId");
@@ -555,6 +677,12 @@ export function parseResolvedWhiteBalanceState(value) {
             measurement === undefined)) {
         throw new InvalidConfigurationError("An auto-white-balance state requires sourceProfile, awbPolicy, and measurement identity.");
     }
+    if ((record.source === "color-temperature") !==
+        (colorTemperature !== undefined) ||
+        (record.source === "color-temperature" &&
+            sourceProfile === undefined)) {
+        throw new InvalidConfigurationError("A color-temperature WB state requires sourceProfile and colorTemperature; other sources must not declare colorTemperature.");
+    }
     if (record.locked &&
         sourceStateId === undefined) {
         throw new InvalidConfigurationError("A locked WB state requires sourceStateId.");
@@ -590,6 +718,11 @@ export function parseResolvedWhiteBalanceState(value) {
             : {
                 measurement
             }),
+        ...(colorTemperature === undefined
+            ? {}
+            : {
+                colorTemperature
+            }),
         ...(sourceStateId === undefined
             ? {}
             : {