iapws-if97 2.2.0 → 2.8.0

package/dist/saturation/region4-hs.js

@@ -1,21 +1,23 @@
 import * as C from '../constants.js';
 import { bracketedNewton } from '../solvers/bracketed-newton.js';
 import { dampedNewton2D } from '../solvers/damped-newton-2d.js';
+import { backwardConstraintTolerance } from '../backward/tolerances.js';
+import { nextPositiveFloat } from '../core/floating-point.js';
 import { IF97Error } from '../types.js';
+import { SaturationEndpointError } from '../errors.js';
 import { mixSaturationState, rawQualityFromSaturationProperty, saturationEndpointsAtTemperature, } from './common.js';
 import { assertRegion4StateAllowed, clampRegion4TemperatureBelowCritical, } from './region4-boundaries.js';
 const REGION4_QUALITY_TOLERANCE = 1e-6;
 const REGION4_ENDPOINT_QUALITY_SNAP_TOLERANCE = 1e-10;
 /** Lower entropy limit of the SR4-04 T_sat(h,s) equation [kJ/(kg·K)].
  *  Published range of validity is s''(623.15 K) = 5.210887825 to
- *  s''(273.15 K) = 9.155759395; both reproduce exactly from Region 2 on the
- *  saturation line. Below this bound Eq. 9 is extrapolation, so the caller
+ *  s''(273.15 K) = 9.155759395. Use the computed Region 2 endpoint rather
+ *  than its rounded table value. Below this bound Eq. 9 is extrapolation, so the caller
  *  falls through to the general Newton path instead.
  *  Ref: IAPWS SR4-04(2014), Eq. 9. */
-const REGION4_HS_BACKWARD_MIN_ENTROPY = 5.210887825;
+const REGION4_HS_BACKWARD_MIN_ENTROPY = saturationEndpointsAtTemperature(C.R2_T_MIN).vapor.entropy;
 const REGION4_HS_ENDPOINT_RESIDUAL_TOLERANCE = 1e-14;
 const REGION4_HS_NEWTON_UPPER = C.Tc - C.REGION4_SUBCRITICAL_TEMPERATURE_MARGIN;
-const REGION4_HS_NEAR_CRITICAL_UPPER = REGION4_HS_NEWTON_UPPER;
 const REGION4_TRIPLE_POINT_ENDPOINTS = saturationEndpointsAtTemperature(C.Tt);
 const REGION4_HS_T = [
     [0, 0, 0.179882673606601], [0, 3, -0.267507455199603], [0, 12, 1.16276722612600],
@@ -121,26 +123,47 @@ function entropyResidualEvaluation(h, s, temperatureGuess) {
 function entropyResidual(h, s, temperatureGuess) {
     return entropyResidualEvaluation(h, s, temperatureGuess).residual;
 }
-function gibbsResidualEvaluation(h, s, temperatureGuess) {
-    const endpoints = saturationEndpointsAtTemperature(clampRegion4TemperatureBelowCritical(temperatureGuess));
-    const T = endpoints.temperature;
-    const { liquid, vapor } = endpoints;
-    const deltaS = vapor.entropy - liquid.entropy;
-    const deltaV = vapor.specificVolume - liquid.specificVolume;
-    const pressureDerivative = deltaS / (1000 * deltaV);
-    return {
-        residual: liquid.enthalpy - T * liquid.entropy + T * s - h,
-        derivative: 1000 * liquid.specificVolume * pressureDerivative - liquid.entropy + s,
-    };
+let region4HSValidCriticalUpper;
+function region4HSCriticalUpper() {
+    if (region4HSValidCriticalUpper !== undefined)
+        return region4HSValidCriticalUpper;
+    let upper = REGION4_HS_NEWTON_UPPER;
+    try {
+        saturationEndpointsAtTemperature(upper);
+    }
+    catch (error) {
+        if (!(error instanceof SaturationEndpointError)) {
+            throw error;
+        }
+        let valid = C.Tc - 1e-4;
+        saturationEndpointsAtTemperature(valid);
+        for (let iteration = 0; iteration < 40; iteration += 1) {
+            const candidate = (valid + upper) / 2;
+            if (candidate === valid || candidate === upper)
+                break;
+            try {
+                saturationEndpointsAtTemperature(candidate);
+                valid = candidate;
+            }
+            catch (error) {
+                if (!(error instanceof SaturationEndpointError)) {
+                    throw error;
+                }
+                upper = candidate;
+            }
+        }
+        upper = valid;
+    }
+    region4HSValidCriticalUpper = upper;
+    return upper;
 }
-function tryRegion4HSGibbsState(h, s) {
+function tryRegion4HSEntropyState(h, s) {
     let cachedTemperature = Number.NaN;
     let cachedEvaluation = null;
     const evaluate = (temperature) => {
-        const stableTemperature = Math.round(temperature / C.REGION4_TEMPERATURE_TOLERANCE) * C.REGION4_TEMPERATURE_TOLERANCE;
-        if (stableTemperature !== cachedTemperature || cachedEvaluation === null) {
-            cachedTemperature = stableTemperature;
-            cachedEvaluation = gibbsResidualEvaluation(h, s, stableTemperature);
+        if (temperature !== cachedTemperature || cachedEvaluation === null) {
+            cachedTemperature = temperature;
+            cachedEvaluation = entropyResidualEvaluation(h, s, temperature);
         }
         return cachedEvaluation;
     };
@@ -156,38 +179,142 @@ function tryRegion4HSGibbsState(h, s) {
             if (!Number.isFinite(value.derivative) || value.derivative === 0)
                 break;
             const candidate = temperature - value.residual / value.derivative;
-            if (!(candidate >= C.Tt && candidate <= C.Tt + 0.1))
+            if (!(candidate >= C.Tt && candidate <= C.R2_T_MIN))
                 break;
-            temperature = Math.round(candidate / C.REGION4_TEMPERATURE_TOLERANCE) * C.REGION4_TEMPERATURE_TOLERANCE;
+            temperature = candidate;
         }
     }
-    if (Math.abs(h - C.R3_H_CRT) >= 10 || Math.abs(s - C.R3_S_CRT) >= 0.1) {
-        return null;
-    }
-    const initialTemperature = C.Tc - 1e-4;
-    try {
-        const initialState = finalizeRegion4HSState(h, s, initialTemperature);
-        if (initialState !== null)
-            return initialState;
-        const root = bracketedNewton((T) => evaluate(T).residual, C.Tc - C.CRITICAL_T_EXCLUSION_BAND, REGION4_HS_NEAR_CRITICAL_UPPER, initialTemperature, {
-            tolerance: C.REGION4_HS_RESIDUAL_TOLERANCE,
-            derivative: (T) => evaluate(T).derivative,
-        });
-        const stableRoot = Math.round(root / C.REGION4_TEMPERATURE_TOLERANCE) * C.REGION4_TEMPERATURE_TOLERANCE;
-        return finalizeRegion4HSState(h, s, stableRoot);
+    // Split the EOS seam; the valid anchor defers critical-ceiling calibration until needed.
+    const intervals = [[C.Tt, C.R2_T_MIN], [nextPositiveFloat(C.R2_T_MIN, 1), C.Tc - 1e-4]];
+    const liquid = s <= C.R3_S_CRT;
+    let numericalFailure = false;
+    let criticalInterval = false;
+    for (const [lower, initialUpper] of intervals) {
+        try {
+            const lowerValue = evaluate(lower);
+            if (Math.abs(lowerValue.residual) <= REGION4_HS_ENDPOINT_RESIDUAL_TOLERANCE) {
+                const state = finalizeRegion4HSState(h, s, lower);
+                if (state !== null)
+                    return state;
+            }
+            if (s < lowerValue.liquidEntropy || s > lowerValue.vaporEntropy) {
+                // Split-EOS endpoint roundoff can exclude a numerically valid root.
+                if (Math.abs(lowerValue.residual) <= C.REGION4_HS_RESIDUAL_TOLERANCE)
+                    numericalFailure = true;
+                continue;
+            }
+            const highTemperature = lower > C.R2_T_MIN;
+            if (highTemperature)
+                criticalInterval = true;
+            let upper = initialUpper;
+            let inside = lower;
+            let outside = upper;
+            let outsideValue = null;
+            let temperature = lower;
+            let value = lowerValue;
+            for (let iteration = 0; iteration < 100; iteration += 1) {
+                if (Math.abs(value.quality) <= REGION4_QUALITY_TOLERANCE ||
+                    Math.abs(value.quality - 1) <= REGION4_QUALITY_TOLERANCE) {
+                    const endpoint = exactEndpointHSState(h, s, temperature, value.quality < 0.5 ? 0 : 1);
+                    if (endpoint !== null)
+                        return endpoint;
+                    const entropyQuality = rawQualityFromSaturationProperty(value.liquidEntropy, value.vaporEntropy, s);
+                    if (endpointQuality(value.quality, entropyQuality) !== null &&
+                        Math.abs(value.residual) <= REGION4_HS_ENDPOINT_RESIDUAL_TOLERANCE) {
+                        const state = finalizeRegion4HSState(h, s, temperature);
+                        if (state !== null)
+                            return state;
+                    }
+                }
+                const entropyInside = s >= value.liquidEntropy && s <= value.vaporEntropy;
+                if (entropyInside) {
+                    inside = temperature;
+                    if (temperature > lower && lowerValue.residual * value.residual <= 0) {
+                        const root = bracketedNewton((T) => evaluate(T).residual, lower, inside, h / s, {
+                            tolerance: REGION4_HS_ENDPOINT_RESIDUAL_TOLERANCE,
+                            derivative: (T) => evaluate(T).derivative,
+                        });
+                        const quality = evaluate(root).quality;
+                        if (Math.abs(quality) > REGION4_QUALITY_TOLERANCE &&
+                            Math.abs(quality - 1) > REGION4_QUALITY_TOLERANCE) {
+                            const state = finalizeRegion4HSState(h, s, root);
+                            if (state !== null)
+                                return state;
+                        }
+                        numericalFailure = true;
+                        break;
+                    }
+                    if (temperature === upper) {
+                        if (highTemperature && upper === initialUpper) {
+                            upper = region4HSCriticalUpper();
+                            if (upper > inside) {
+                                outside = upper;
+                                temperature = upper;
+                                value = evaluate(temperature);
+                                continue;
+                            }
+                        }
+                        if (Math.abs(value.residual) <= REGION4_HS_ENDPOINT_RESIDUAL_TOLERANCE) {
+                            numericalFailure = true;
+                        }
+                        break;
+                    }
+                }
+                else {
+                    outside = temperature;
+                    outsideValue = value;
+                }
+                const midpoint = (inside + outside) / 2;
+                if (midpoint === inside || midpoint === outside) {
+                    if (Math.abs(value.residual) <= C.REGION4_HS_RESIDUAL_TOLERANCE ||
+                        (outsideValue !== null && lowerValue.residual * outsideValue.residual <= 0)) {
+                        numericalFailure = true;
+                    }
+                    break;
+                }
+                const phaseResidual = (liquid ? value.liquidEntropy : value.vaporEntropy) - s;
+                const derivative = liquid ? value.liquidDsDT : value.vaporDsDT;
+                // A rounded entropy zero is still inside; retain an outside bound one float higher.
+                const candidate = phaseResidual === 0
+                    ? nextPositiveFloat(temperature, 1)
+                    : temperature - phaseResidual / derivative;
+                temperature = Number.isFinite(candidate) && candidate > inside && candidate < outside
+                    ? candidate
+                    : outsideValue === null ? outside : midpoint;
+                value = evaluate(temperature);
+                if (iteration === 99)
+                    numericalFailure = true;
+            }
+        }
+        catch (error) {
+            if (!(error instanceof IF97Error))
+                throw error;
+            numericalFailure = true;
+        }
     }
-    catch (error) {
-        if (!(error instanceof IF97Error))
-            throw error;
+    if (numericalFailure && criticalInterval) {
+        try {
+            const root = bracketedNewton((T) => evaluate(T).residual, 645, region4HSCriticalUpper(), C.Tc - 1e-4, {
+                tolerance: REGION4_HS_ENDPOINT_RESIDUAL_TOLERANCE,
+                derivative: (T) => evaluate(T).derivative,
+            });
+            const state = finalizeRegion4HSState(h, s, root);
+            if (state !== null)
+                return state;
+        }
+        catch (error) {
+            if (!(error instanceof IF97Error))
+                throw error;
+        }
     }
-    return null;
+    return numericalFailure ? tryRegion4HSNewtonState(h, s) : null;
 }
 function tryRegion4HSNewtonState(h, s) {
     // h/s carries units of K and, because IF97 zeroes h and s at the triple-point
     // liquid, approximates the mean temperature of heat addition from that state —
     // close enough to land inside the dome for most inputs. It is clamped to the
     // saturation range and backed by fixed seeds spanning Tt to just below Tc.
-    const seeds = [h / s, 300, 400, 500, 580, 630, 645];
+    const seeds = [h / s, 300, 400, 500, 580, 630, 645, nextPositiveFloat(C.R2_T_MIN, 1)];
     const tried = new Set();
     const hScale = Math.max(1, Math.abs(h));
     const sScale = Math.max(1, Math.abs(s));
@@ -221,13 +348,13 @@ function tryRegion4HSNewtonState(h, s) {
                     ],
                 };
             }, [seed, initialValue.quality], {
-                tolerance: 1e-12,
-                maxIterations: 30,
-                isValid: ([T]) => T >= C.Tt && T <= REGION4_HS_NEWTON_UPPER,
+                tolerance: seed <= C.R2_T_MIN ? REGION4_HS_ENDPOINT_RESIDUAL_TOLERANCE : 1e-12,
+                maxIterations: 60,
+                isValid: ([T]) => T >= C.Tt && T <= REGION4_HS_NEWTON_UPPER &&
+                    (seed <= C.R2_T_MIN ? T <= C.R2_T_MIN : T > C.R2_T_MIN),
             });
             if (isAdmissibleQuality(quality)) {
-                const stableTemperature = Math.round(temperature / C.REGION4_TEMPERATURE_TOLERANCE) * C.REGION4_TEMPERATURE_TOLERANCE;
-                const state = finalizeRegion4HSState(h, s, stableTemperature);
+                const state = finalizeRegion4HSState(h, s, temperature);
                 if (state !== null)
                     return state;
             }
@@ -244,11 +371,10 @@ function finalizeRegion4HSState(h, s, temperature) {
     const qualityFromEnthalpy = rawQualityFromSaturationProperty(endpoints.liquid.enthalpy, endpoints.vapor.enthalpy, h);
     const qualityFromEntropy = rawQualityFromSaturationProperty(endpoints.liquid.entropy, endpoints.vapor.entropy, s);
     const normalizedQualityFromEnthalpy = normalizeEndpointQuality(qualityFromEnthalpy);
-    const normalizedQualityFromEntropy = normalizeEndpointQuality(qualityFromEntropy);
-    if (!isAdmissibleQuality(normalizedQualityFromEnthalpy) || !isAdmissibleQuality(normalizedQualityFromEntropy)) {
+    if (!isAdmissibleQuality(qualityFromEnthalpy) || !isAdmissibleQuality(qualityFromEntropy)) {
         return null;
     }
-    if (Math.abs(normalizedQualityFromEnthalpy - normalizedQualityFromEntropy) > REGION4_QUALITY_TOLERANCE) {
+    if (Math.abs(qualityFromEnthalpy - qualityFromEntropy) > REGION4_QUALITY_TOLERANCE) {
         return null;
     }
     const mixedEntropy = endpoints.liquid.entropy * (1 - qualityFromEnthalpy) +
@@ -262,8 +388,112 @@ function finalizeRegion4HSState(h, s, temperature) {
     catch {
         return null;
     }
-    const exactEndpointQuality = endpointQuality(qualityFromEnthalpy, qualityFromEntropy);
-    return mixSaturationState(endpoints, exactEndpointQuality ?? normalizedQualityFromEnthalpy);
+    let exactEndpointQuality = endpointQuality(qualityFromEnthalpy, qualityFromEntropy);
+    if (exactEndpointQuality !== null) {
+        const endpoint = exactEndpointQuality === 0 ? endpoints.liquid : endpoints.vapor;
+        if (Math.abs(endpoint.enthalpy - h) > backwardConstraintTolerance('enthalpy', h) ||
+            Math.abs(endpoint.entropy - s) > backwardConstraintTolerance('entropy', s)) {
+            if (qualityFromEnthalpy < 0 || qualityFromEnthalpy > 1 ||
+                qualityFromEntropy < 0 || qualityFromEntropy > 1)
+                return null;
+            exactEndpointQuality = null;
+        }
+    }
+    const state = mixSaturationState(endpoints, exactEndpointQuality ?? normalizedQualityFromEnthalpy);
+    // A quality clamp must not turn a single-phase input into an approximate endpoint.
+    if (qualityFromEnthalpy < 0 || qualityFromEnthalpy > 1 ||
+        qualityFromEntropy < 0 || qualityFromEntropy > 1 || state.quality === 0 || state.quality === 1) {
+        // Preserve the existing endpoint quality resolution in both reconstructed properties.
+        const enthalpyTolerance = Math.max(1e-9, (endpoints.vapor.enthalpy - endpoints.liquid.enthalpy) * REGION4_ENDPOINT_QUALITY_SNAP_TOLERANCE);
+        const entropyTolerance = Math.max(1e-12, (endpoints.vapor.entropy - endpoints.liquid.entropy) * REGION4_ENDPOINT_QUALITY_SNAP_TOLERANCE);
+        if ((state.quality !== 0 && state.quality !== 1) ||
+            Math.abs(state.enthalpy - h) > enthalpyTolerance || Math.abs(state.entropy - s) > entropyTolerance) {
+            return null;
+        }
+    }
+    if (Math.abs(state.enthalpy - h) > backwardConstraintTolerance('enthalpy', h) ||
+        Math.abs(state.entropy - s) > backwardConstraintTolerance('entropy', s)) {
+        return null;
+    }
+    const nearbyEndpoint = Math.abs(qualityFromEnthalpy) <= REGION4_QUALITY_TOLERANCE &&
+        Math.abs(qualityFromEntropy) <= REGION4_QUALITY_TOLERANCE ? 0 :
+        Math.abs(qualityFromEnthalpy - 1) <= REGION4_QUALITY_TOLERANCE &&
+            Math.abs(qualityFromEntropy - 1) <= REGION4_QUALITY_TOLERANCE ? 1 : null;
+    if (exactEndpointQuality === null && nearbyEndpoint !== null &&
+        state.quality !== null && state.quality > 0 && state.quality < 1) {
+        try {
+            const endpoint = exactEndpointHSState(h, s, temperature, nearbyEndpoint);
+            if (endpoint !== null)
+                return endpoint;
+        }
+        catch (error) {
+            if (!(error instanceof IF97Error))
+                throw error;
+        }
+    }
+    return state;
+}
+function exactEndpointHSState(h, s, initialTemperature, quality) {
+    const valueAt = (T) => entropyResidualEvaluation(h, s, T);
+    const enthalpyAt = (T) => {
+        const value = valueAt(T);
+        return quality === 0 ? value.liquidEnthalpy : value.vaporEnthalpy;
+    };
+    const derivativeAt = (T) => {
+        const value = valueAt(T);
+        return quality === 0 ? value.liquidDhDT : value.vaporDhDT;
+    };
+    let temperature = initialTemperature;
+    let previousTemperature = Number.NaN;
+    let previousResidual = Number.NaN;
+    for (let iteration = 0; iteration < 8; iteration += 1) {
+        const endpoints = saturationEndpointsAtTemperature(temperature);
+        const state = quality === 0 ? endpoints.liquid : endpoints.vapor;
+        if (state.enthalpy === h && state.entropy === s) {
+            assertRegion4StateAllowed(endpoints.pressure, endpoints.temperature, 'Region4HS');
+            return mixSaturationState(endpoints, quality);
+        }
+        const residual = state.enthalpy - h;
+        if (previousResidual * residual < 0) {
+            const root = bracketedNewton((T) => enthalpyAt(T) - h, previousTemperature, temperature, undefined, { tolerance: Number.EPSILON, derivative: derivativeAt });
+            let below = root;
+            let above = root;
+            // EOS cancellation can reverse the enthalpy sign before the exact endpoint float.
+            for (let neighbor = 0; neighbor < 8; neighbor += 1) {
+                for (const candidate of neighbor === 0 ? [root] : [below, above]) {
+                    if (candidate < C.Tt || candidate > REGION4_HS_NEWTON_UPPER ||
+                        (candidate <= C.R2_T_MIN) !== (initialTemperature <= C.R2_T_MIN))
+                        continue;
+                    const refined = saturationEndpointsAtTemperature(candidate);
+                    const endpoint = quality === 0 ? refined.liquid : refined.vapor;
+                    if (endpoint.enthalpy !== h || endpoint.entropy !== s)
+                        continue;
+                    assertRegion4StateAllowed(refined.pressure, refined.temperature, 'Region4HS');
+                    return mixSaturationState(refined, quality);
+                }
+                below = nextPositiveFloat(below, -1);
+                above = nextPositiveFloat(above, 1);
+            }
+            return null;
+        }
+        const value = valueAt(temperature);
+        const derivative = residual === 0
+            ? quality === 0 ? value.liquidDsDT : value.vaporDsDT
+            : quality === 0 ? value.liquidDhDT : value.vaporDhDT;
+        const correction = (residual === 0 ? state.entropy - s : residual) / derivative;
+        const newtonTemperature = temperature - correction;
+        const candidate = newtonTemperature === temperature && correction !== 0
+            ? nextPositiveFloat(temperature, correction > 0 ? -1 : 1)
+            : newtonTemperature;
+        if (!Number.isFinite(candidate) || candidate === temperature || candidate < C.Tt ||
+            candidate > REGION4_HS_NEWTON_UPPER ||
+            (candidate <= C.R2_T_MIN) !== (initialTemperature <= C.R2_T_MIN))
+            return null;
+        previousTemperature = temperature;
+        previousResidual = residual;
+        temperature = candidate;
+    }
+    return null;
 }
 function isTriplePointHS(h, s) {
     const { liquid, vapor } = REGION4_TRIPLE_POINT_ENDPOINTS;
@@ -324,11 +554,5 @@ export function tryRegion4HSState(h, s) {
     const backwardState = tryRegion4HSBackwardState(h, s);
     if (backwardState !== null)
         return backwardState;
-    const gibbsState = tryRegion4HSGibbsState(h, s);
-    if (gibbsState !== null)
-        return gibbsState;
-    const newtonState = tryRegion4HSNewtonState(h, s);
-    if (newtonState !== null)
-        return newtonState;
-    return null;
+    return tryRegion4HSEntropyState(h, s);
 }

package/dist/saturation/two-phase.d.ts

@@ -9,13 +9,13 @@
 import type { BasicProperties } from '../types.js';
 /**
  * Solve for thermodynamic state given pressure and vapour quality.
- * @param p - Pressure [MPa], Pt <= p <= Pc
+ * @param p - Pressure [MPa], Pt <= p < Pc
  * @param x - Vapour quality [0, 1]
  */
 export declare function solvePx(p: number, x: number): BasicProperties;
 /**
  * Solve for thermodynamic state given temperature and vapour quality.
- * @param T - Temperature [K], T_MIN <= T <= Tc
+ * @param T - Temperature [K], Tt <= T < Tc
  * @param x - Vapour quality [0, 1]
  */
 export declare function solveTx(T: number, x: number): BasicProperties;

package/dist/saturation/two-phase.js

@@ -8,13 +8,12 @@
  */
 import { OutOfRangeError } from '../types.js';
 import { assertFiniteNumber } from '../core/input-validation.js';
-import { saturationPressure } from '../regions/region4.js';
-import { mixSaturationState, saturationEndpointsAtPressure } from './common.js';
-import { assertRegion4PressureStateInput, assertRegion4TemperatureStateInput, normalizeRegion4Pressure, } from './region4-boundaries.js';
+import { mixSaturationState, saturationEndpointsAtPressure, saturationEndpointsAtTemperature, } from './common.js';
+import { assertRegion4PressureStateInput, assertRegion4TemperatureStateInput, } from './region4-boundaries.js';
 // ─── solvePx ────────────────────────────────────────────────────────────────
 /**
  * Solve for thermodynamic state given pressure and vapour quality.
- * @param p - Pressure [MPa], Pt <= p <= Pc
+ * @param p - Pressure [MPa], Pt <= p < Pc
  * @param x - Vapour quality [0, 1]
  */
 export function solvePx(p, x) {
@@ -28,7 +27,7 @@ export function solvePx(p, x) {
 // ─── solveTx ────────────────────────────────────────────────────────────────
 /**
  * Solve for thermodynamic state given temperature and vapour quality.
- * @param T - Temperature [K], T_MIN <= T <= Tc
+ * @param T - Temperature [K], Tt <= T < Tc
  * @param x - Vapour quality [0, 1]
  */
 export function solveTx(T, x) {
@@ -38,6 +37,7 @@ export function solveTx(T, x) {
         throw new OutOfRangeError('Quality', x, 0, 1);
     }
     const temperature = assertRegion4TemperatureStateInput(T, 'solveTx');
-    const p = normalizeRegion4Pressure(saturationPressure(temperature));
-    return solvePx(p, x);
+    const endpoints = saturationEndpointsAtTemperature(temperature);
+    assertRegion4PressureStateInput(endpoints.pressure, 'solveTx');
+    return mixSaturationState(endpoints, x);
 }

package/dist/solvers/bracketed-newton.d.ts

@@ -1,7 +1,9 @@
 /** Configuration for the bracketed Newton solver. */
 export interface BracketedNewtonOptions {
-    /** Convergence tolerance on |f(x)| (default 1e-9) */
+    /** Bracket-width tolerance scaled by max(1, |x|), also the default residual tolerance (default 1e-9). */
     tolerance?: number;
+    /** Tolerance on |f(x)| (defaults to tolerance); 0 requires exact zero or bracket convergence. */
+    residualTolerance?: number;
     /** Maximum number of iterations (default 100) */
     maxIterations?: number;
     /** Relative step size for central-difference derivative (default 1e-6) */
@@ -14,14 +16,15 @@ export interface BracketedNewtonOptions {
  *
  * Each iteration attempts a Newton step using the supplied analytical derivative,
  * or a central difference when none is supplied. If the Newton candidate falls
- * outside the current bracket, a bisection step is used instead.
+ * outside the current bracket, or two iterations fail to halve its width,
+ * a bisection step is used instead.
  *
  * @param f            - Continuous function whose root is sought
  * @param lower        - Lower bound of the bracket
  * @param upper        - Upper bound of the bracket
  * @param initialGuess - Optional starting point (must lie within bracket)
  * @param options      - Solver configuration
- * @returns The root x such that |f(x)| ≤ tolerance
+ * @returns A root satisfying the residual tolerance or bracket-width convergence criterion
  * @throws {ConvergenceError} if the bracket signs are the same or max iterations exceeded
  */
 export declare function bracketedNewton(f: (x: number) => number, lower: number, upper: number, initialGuess?: number, options?: BracketedNewtonOptions): number;

package/dist/solvers/bracketed-newton.js

@@ -3,8 +3,8 @@
  *
  * A hybrid root-finder that combines Newton-Raphson steps with bisection
  * fallback. The bracket [lower, upper] is maintained so that f(a) and f(b)
- * have opposite signs, guaranteeing convergence even when the Newton step
- * would overshoot or the derivative estimate is poor.
+ * have opposite signs. A stagnation safeguard forces bisection when two
+ * iterations fail to halve the bracket.
  */
 import { ConvergenceError, IF97Error } from '../types.js';
 /**
@@ -22,27 +22,29 @@ function numericalDerivative(f, x, lower, upper, step) {
  *
  * Each iteration attempts a Newton step using the supplied analytical derivative,
  * or a central difference when none is supplied. If the Newton candidate falls
- * outside the current bracket, a bisection step is used instead.
+ * outside the current bracket, or two iterations fail to halve its width,
+ * a bisection step is used instead.
  *
  * @param f            - Continuous function whose root is sought
  * @param lower        - Lower bound of the bracket
  * @param upper        - Upper bound of the bracket
  * @param initialGuess - Optional starting point (must lie within bracket)
  * @param options      - Solver configuration
- * @returns The root x such that |f(x)| ≤ tolerance
+ * @returns A root satisfying the residual tolerance or bracket-width convergence criterion
  * @throws {ConvergenceError} if the bracket signs are the same or max iterations exceeded
  */
 export function bracketedNewton(f, lower, upper, initialGuess, options) {
     const tolerance = options?.tolerance ?? 1e-9;
+    const residualTolerance = options?.residualTolerance ?? tolerance;
     const maxIterations = options?.maxIterations ?? 100;
     const derivativeStep = options?.derivativeStep ?? 1e-6;
     let a = Math.min(lower, upper);
     let b = Math.max(lower, upper);
     let fa = f(a);
     let fb = f(b);
-    if (Math.abs(fa) <= tolerance)
+    if (Math.abs(fa) <= residualTolerance)
         return a;
-    if (Math.abs(fb) <= tolerance)
+    if (Math.abs(fb) <= residualTolerance)
         return b;
     if (fa * fb > 0) {
         throw new IF97Error(`bracketedNewton: f(${a}) and f(${b}) have the same sign (${fa.toExponential(3)}, ${fb.toExponential(3)}); bracket does not contain a root`);
@@ -51,9 +53,11 @@ export function bracketedNewton(f, lower, upper, initialGuess, options) {
     if (!(x > a && x < b)) {
         x = (a + b) / 2;
     }
+    let previousWidth = b - a;
+    let widthTwoStepsAgo = previousWidth;
     for (let iter = 0; iter < maxIterations; iter++) {
         const fx = f(x);
-        if (Math.abs(fx) <= tolerance) {
+        if (Math.abs(fx) <= residualTolerance) {
             return x;
         }
         if (fa * fx < 0) {
@@ -75,9 +79,12 @@ export function bracketedNewton(f, lower, upper, initialGuess, options) {
         const newtonCandidate = derivative === null || !Number.isFinite(derivative) || derivative === 0
             ? NaN
             : x - fx / derivative;
-        x = Number.isFinite(newtonCandidate) && newtonCandidate > a && newtonCandidate < b
+        const sufficientProgress = iter === 0 || b - a <= widthTwoStepsAgo / 2;
+        x = sufficientProgress && Number.isFinite(newtonCandidate) && newtonCandidate > a && newtonCandidate < b
             ? newtonCandidate
             : midpoint;
+        widthTwoStepsAgo = previousWidth;
+        previousWidth = b - a;
     }
     throw new ConvergenceError('bracketedNewton', maxIterations);
 }

package/dist/solvers/extended-arithmetic.d.ts

@@ -0,0 +1,6 @@
+export type DoubleDouble = readonly [number, number];
+export declare function addExtended(a: DoubleDouble, b: DoubleDouble): DoubleDouble;
+export declare function multiplyExtended(a: DoubleDouble, b: DoubleDouble): DoubleDouble;
+export declare function divideExtended(a: DoubleDouble, b: DoubleDouble): DoubleDouble;
+export declare function subtractExtended(a: DoubleDouble, b: DoubleDouble): DoubleDouble;
+export declare function sqrtExtended(value: DoubleDouble): DoubleDouble;

package/dist/solvers/extended-arithmetic.js

@@ -0,0 +1,38 @@
+function twoSum(a, b) {
+    const sum = a + b;
+    const recoveredB = sum - a;
+    return [sum, (a - (sum - recoveredB)) + (b - recoveredB)];
+}
+function twoProduct(a, b) {
+    const product = a * b;
+    // Dekker's split for binary64: 2^27 + 1.
+    const splitA = 134217729 * a;
+    const highA = splitA - (splitA - a);
+    const lowA = a - highA;
+    const splitB = 134217729 * b;
+    const highB = splitB - (splitB - b);
+    const lowB = b - highB;
+    return [product, ((highA * highB - product) + highA * lowB + lowA * highB) + lowA * lowB];
+}
+export function addExtended(a, b) {
+    const [sum, error] = twoSum(a[0], b[0]);
+    return twoSum(sum, error + a[1] + b[1]);
+}
+export function multiplyExtended(a, b) {
+    const [product, error] = twoProduct(a[0], b[0]);
+    return twoSum(product, error + a[0] * b[1] + a[1] * b[0]);
+}
+export function divideExtended(a, b) {
+    const quotient = a[0] / b[0];
+    const product = multiplyExtended([quotient, 0], b);
+    const residual = addExtended(a, [-product[0], -product[1]]);
+    return addExtended([quotient, 0], [residual[0] / b[0], 0]);
+}
+export function subtractExtended(a, b) {
+    return addExtended(a, [-b[0], -b[1]]);
+}
+export function sqrtExtended(value) {
+    const initial = Math.sqrt(value[0]);
+    const residual = subtractExtended(value, multiplyExtended([initial, 0], [initial, 0]));
+    return addExtended([initial, 0], divideExtended(residual, [2 * initial, 0]));
+}

package/dist/transport/properties.d.ts

@@ -11,6 +11,7 @@
  * Dynamic viscosity of water/steam [Pa·s]
  * @param T   Temperature [K]
  * @param rho Density [kg/m³]
+ * @throws {IF97Error} If the calculated viscosity is non-finite or non-positive.
  */
 export declare function viscosity(T: number, rho: number): number;
 /**
@@ -22,7 +23,7 @@ export declare function viscosity(T: number, rho: number): number;
  *
  * @param T   Temperature [K]
  * @param rho Density [kg/m³]
- * @param cp  Isobaric heat capacity [kJ/(kg·K)] (optional)
+ * @param cp  Positive isobaric heat capacity [kJ/(kg·K)] (optional)
  * @param cv  Isochoric heat capacity [kJ/(kg·K)] (optional)
  * @param drhodP_T  Isothermal density derivative ∂ρ/∂P|_T [kg/m³/MPa] (optional)
  * @param mu  Dynamic viscosity [Pa·s] (optional)
@@ -36,8 +37,9 @@ export declare function thermalConductivity(T: number, rho: number, cp?: number,
 export declare function surfaceTension(T: number): number | null;
 /**
  * Static dielectric constant [dimensionless]
- * @param T   Temperature [K]
+ * @param T   Temperature [K], must be greater than 228 K
  * @param rho Density [kg/m³]
+ * @throws {IF97Error} If T is at or below the equation's 228 K singularity.
  */
 export declare function dielectricConstant(T: number, rho: number): number;
 /**