iapws-if97 2.1.5 → 2.2.0

package/dist/saturation/common.d.ts

@@ -48,4 +48,3 @@ export declare function qualityFromSaturationProperty(liquidValue: number, vapor
  * @param qualityInput - Vapour quality (0–1)
  */
 export declare function mixSaturationState(endpoints: SaturationEndpoints, qualityInput: number): BasicProperties;
-//# sourceMappingURL=common.d.ts.map

package/dist/saturation/common.js

@@ -5,27 +5,21 @@ import { region2 } from '../regions/region2.js';
 import { region3ByRhoT } from '../regions/region3.js';
 import { saturationPressure, saturationTemperature } from '../regions/region4.js';
 import { region3SatVolume } from '../regions/region3-subregions.js';
-import { newtonRaphson } from '../solvers/newton-raphson.js';
+import { solveRegion3StateAtPressure } from '../core/region3-pt.js';
 import { normalizeRegion4Pressure, normalizeRegion4Temperature, } from './region4-boundaries.js';
 /** Tag a single-phase state as Region 4 with the given vapour quality. */
 function withRegion4Metadata(state, quality) {
     return { ...state, region: Region.Region4, quality };
 }
 /**
- * Iteratively solve for Region 3 density at saturation.
+ * Solve for the Region 3 saturation endpoint state.
  *
  * @param p - Saturation pressure [MPa]
  * @param T - Saturation temperature [K]
  * @param x - Phase indicator: 0 = liquid, 1 = vapour
  */
-function solveR3Density(p, T, x) {
-    const v0 = region3SatVolume(p, T, x);
-    return newtonRaphson((rho) => {
-        if (!Number.isFinite(rho) || rho <= 0) {
-            return Number.NaN;
-        }
-        return region3ByRhoT(rho, T).pressure - p;
-    }, 1 / v0);
+function solveR3Endpoint(p, T, x) {
+    return solveRegion3StateAtPressure(p, T, 1 / region3SatVolume(p, T, x));
 }
 /** Clamp vapour quality to [0, 1], snapping near-zero/one values to the boundary. */
 function clampQuality(x) {
@@ -69,8 +63,8 @@ export function saturationEndpointsAtPressure(p) {
         return {
             pressure,
             temperature,
-            liquid: region3ByRhoT(solveR3Density(pressure, temperature, 0), temperature),
-            vapor: region3ByRhoT(solveR3Density(pressure, temperature, 1), temperature),
+            liquid: solveR3Endpoint(pressure, temperature, 0),
+            vapor: solveR3Endpoint(pressure, temperature, 1),
         };
     }
     return {
@@ -150,4 +144,3 @@ export function mixSaturationState(endpoints, qualityInput) {
         isothermalCompressibility: null,
     };
 }
-//# sourceMappingURL=common.js.map

package/dist/saturation/region4-boundaries.d.ts

@@ -1,14 +1,9 @@
 export declare function normalizeRegion4Pressure(p: number): number;
 export declare function normalizeRegion4Temperature(T: number): number;
 export declare function clampRegion4TemperatureBelowCritical(T: number): number;
-export declare function isRegion4CriticalPressure(p: number): boolean;
-export declare function isRegion4CriticalTemperature(T: number): boolean;
 export declare function assertRegion4PressureStateInput(p: number, solverName: string): number;
 export declare function assertRegion4TemperatureStateInput(T: number, solverName: string): number;
 export declare function assertRegion4StateAllowed(pressure: number, temperature: number, solverName: string): void;
-export declare function isCriticalRegion4Enthalpy(h: number): boolean;
-export declare function isCriticalRegion4Entropy(s: number): boolean;
 export declare function assertCriticalRegion4PHInput(p: number, h: number, solverName: string): void;
 export declare function assertCriticalRegion4PSInput(p: number, s: number, solverName: string): void;
 export declare function assertCriticalRegion4HSInput(h: number, s: number, solverName: string): void;
-//# sourceMappingURL=region4-boundaries.d.ts.map

package/dist/saturation/region4-boundaries.js

@@ -21,10 +21,10 @@ export function normalizeRegion4Temperature(T) {
 export function clampRegion4TemperatureBelowCritical(T) {
     return Math.max(C.Tt, Math.min(T, C.Tc - C.REGION4_SUBCRITICAL_TEMPERATURE_MARGIN));
 }
-export function isRegion4CriticalPressure(p) {
+function isRegion4CriticalPressure(p) {
     return normalizeRegion4Pressure(p) === C.Pc;
 }
-export function isRegion4CriticalTemperature(T) {
+function isRegion4CriticalTemperature(T) {
     return normalizeRegion4Temperature(T) === C.Tc;
 }
 function criticalPointMessage(solverName) {
@@ -55,10 +55,10 @@ export function assertRegion4StateAllowed(pressure, temperature, solverName) {
         throw new IF97Error(criticalPointMessage(solverName));
     }
 }
-export function isCriticalRegion4Enthalpy(h) {
+function isCriticalRegion4Enthalpy(h) {
     return Math.abs(h - C.R3_H_CRT) <= C.REGION4_CRITICAL_HS_TOLERANCE;
 }
-export function isCriticalRegion4Entropy(s) {
+function isCriticalRegion4Entropy(s) {
     return Math.abs(s - C.R3_S_CRT) <= C.REGION4_CRITICAL_HS_TOLERANCE;
 }
 export function assertCriticalRegion4PHInput(p, h, solverName) {
@@ -76,4 +76,3 @@ export function assertCriticalRegion4HSInput(h, s, solverName) {
         throw new IF97Error(criticalPointMessage(solverName));
     }
 }
-//# sourceMappingURL=region4-boundaries.js.map

package/dist/saturation/region4-hs.d.ts

@@ -1,3 +1,4 @@
 import type { BasicProperties } from '../types.js';
+/** IAPWS SR4-04(2014), Eq. 9. Valid for Region 4 states at T <= 623.15 K. */
+export declare function region4BackwardTemperatureHS(h: number, s: number): number;
 export declare function tryRegion4HSState(h: number, s: number): BasicProperties | null;
-//# sourceMappingURL=region4-hs.d.ts.map

package/dist/saturation/region4-hs.js

@@ -1,19 +1,54 @@
 import * as C from '../constants.js';
 import { bracketedNewton } from '../solvers/bracketed-newton.js';
+import { dampedNewton2D } from '../solvers/damped-newton-2d.js';
+import { IF97Error } from '../types.js';
 import { mixSaturationState, rawQualityFromSaturationProperty, saturationEndpointsAtTemperature, } from './common.js';
 import { assertRegion4StateAllowed, clampRegion4TemperatureBelowCritical, } from './region4-boundaries.js';
 const REGION4_QUALITY_TOLERANCE = 1e-6;
-function isClose(a, b) {
-    return Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));
+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
+ *  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_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],
+    [1, 0, 0.147545428713616], [1, 1, -0.512871635973248], [1, 2, 0.421333567697984],
+    [1, 5, 0.563749522189870], [2, 0, 0.429274443819153], [2, 5, -3.35704552142140],
+    [2, 8, 10.8890916499278], [3, 0, -0.248483390456012], [3, 2, 0.304153221906390],
+    [3, 3, -0.494819763939905], [3, 4, 1.07551674933261], [4, 0, 0.0733888415457688],
+    [4, 1, 0.0140170545411085], [5, 1, -0.106110975998808], [5, 2, 0.0168324361811875],
+    [5, 4, 1.25028363714877], [5, 16, 1013.16840309509], [6, 6, -1.51791558000712],
+    [6, 8, 52.4277865990866], [6, 22, 23049.5545563912], [8, 1, 0.0249459806365456],
+    [10, 20, 2107964.67412137], [10, 36, 366836848.613065], [12, 24, -144814105.365163],
+    [14, 1, -0.00179276373003590], [14, 28, 4899556021.00459], [16, 12, 471.262212070518],
+    [16, 32, -82929439019.8652], [18, 14, -1715.45662263191], [18, 22, 3557776.82973575],
+    [18, 36, 586062760258.436], [20, 24, -12988763.5078195], [28, 36, 31724744937.1057],
+];
+/** IAPWS SR4-04(2014), Eq. 9. Valid for Region 4 states at T <= 623.15 K. */
+export function region4BackwardTemperatureHS(h, s) {
+    const eta = h / 2800;
+    const sigma = s / 9.2;
+    let theta = 0;
+    for (const [I, J, n] of REGION4_HS_T) {
+        theta += n * Math.pow(eta - 0.119, I) * Math.pow(sigma - 1.07, J);
+    }
+    return 550 * theta;
 }
 function normalizeEndpointQuality(quality) {
     if (!Number.isFinite(quality)) {
         return Number.NaN;
     }
-    if (Math.abs(quality) <= REGION4_QUALITY_TOLERANCE) {
+    if (quality < 0 && quality >= -REGION4_QUALITY_TOLERANCE) {
         return 0;
     }
-    if (Math.abs(quality - 1) <= REGION4_QUALITY_TOLERANCE) {
+    if (quality > 1 && quality <= 1 + REGION4_QUALITY_TOLERANCE) {
         return 1;
     }
     return quality;
@@ -23,13 +58,186 @@ function isAdmissibleQuality(quality) {
         && quality >= -REGION4_QUALITY_TOLERANCE
         && quality <= 1 + REGION4_QUALITY_TOLERANCE;
 }
-function entropyResidual(h, s, temperatureGuess) {
+function endpointQuality(qualityFromEnthalpy, qualityFromEntropy) {
+    if (Math.abs(qualityFromEnthalpy) <= REGION4_ENDPOINT_QUALITY_SNAP_TOLERANCE &&
+        Math.abs(qualityFromEntropy) <= REGION4_ENDPOINT_QUALITY_SNAP_TOLERANCE) {
+        return 0;
+    }
+    if (Math.abs(qualityFromEnthalpy - 1) <= REGION4_ENDPOINT_QUALITY_SNAP_TOLERANCE &&
+        Math.abs(qualityFromEntropy - 1) <= REGION4_ENDPOINT_QUALITY_SNAP_TOLERANCE) {
+        return 1;
+    }
+    return null;
+}
+function entropyResidualEvaluation(h, s, temperatureGuess) {
     const endpoints = saturationEndpointsAtTemperature(clampRegion4TemperatureBelowCritical(temperatureGuess));
-    const quality = rawQualityFromSaturationProperty(endpoints.liquid.enthalpy, endpoints.vapor.enthalpy, h);
+    const T = endpoints.temperature;
+    const { liquid, vapor } = endpoints;
+    const quality = rawQualityFromSaturationProperty(liquid.enthalpy, vapor.enthalpy, h);
     if (!Number.isFinite(quality)) {
-        return Number.NaN;
+        return {
+            residual: Number.NaN,
+            derivative: Number.NaN,
+            quality,
+            liquidEnthalpy: liquid.enthalpy,
+            vaporEnthalpy: vapor.enthalpy,
+            liquidEntropy: liquid.entropy,
+            vaporEntropy: vapor.entropy,
+            liquidDhDT: Number.NaN,
+            vaporDhDT: Number.NaN,
+            liquidDsDT: Number.NaN,
+            vaporDsDT: Number.NaN,
+        };
+    }
+    const deltaH = vapor.enthalpy - liquid.enthalpy;
+    const deltaS = vapor.entropy - liquid.entropy;
+    const deltaV = vapor.specificVolume - liquid.specificVolume;
+    const pressureDerivative = deltaS / (1000 * deltaV);
+    const phaseDerivatives = (state) => {
+        const cp = state.cp ?? Number.NaN;
+        const alpha = state.isobaricExpansion ?? Number.NaN;
+        return [
+            cp + 1000 * state.specificVolume * (1 - T * alpha) * pressureDerivative,
+            cp / T - 1000 * state.specificVolume * alpha * pressureDerivative,
+        ];
+    };
+    const [liquidDhDT, liquidDsDT] = phaseDerivatives(liquid);
+    const [vaporDhDT, vaporDsDT] = phaseDerivatives(vapor);
+    const qualityDerivative = -(liquidDhDT + quality * (vaporDhDT - liquidDhDT)) / deltaH;
+    return {
+        residual: liquid.entropy * (1 - quality) + vapor.entropy * quality - s,
+        derivative: liquidDsDT + quality * (vaporDsDT - liquidDsDT) + qualityDerivative * deltaS,
+        quality,
+        liquidEnthalpy: liquid.enthalpy,
+        vaporEnthalpy: vapor.enthalpy,
+        liquidEntropy: liquid.entropy,
+        vaporEntropy: vapor.entropy,
+        liquidDhDT,
+        vaporDhDT,
+        liquidDsDT,
+        vaporDsDT,
+    };
+}
+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,
+    };
+}
+function tryRegion4HSGibbsState(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);
+        }
+        return cachedEvaluation;
+    };
+    if (h < 10 && s < 0.1) {
+        let temperature = C.Tt;
+        for (let iteration = 0; iteration < 20; iteration += 1) {
+            const value = entropyResidualEvaluation(h, s, temperature);
+            if (Math.abs(value.residual) <= REGION4_HS_ENDPOINT_RESIDUAL_TOLERANCE) {
+                const state = finalizeRegion4HSState(h, s, temperature);
+                if (state !== null)
+                    return state;
+            }
+            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))
+                break;
+            temperature = Math.round(candidate / C.REGION4_TEMPERATURE_TOLERANCE) * C.REGION4_TEMPERATURE_TOLERANCE;
+        }
+    }
+    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);
     }
-    return endpoints.liquid.entropy * (1 - quality) + endpoints.vapor.entropy * quality - s;
+    catch (error) {
+        if (!(error instanceof IF97Error))
+            throw error;
+    }
+    return 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 tried = new Set();
+    const hScale = Math.max(1, Math.abs(h));
+    const sScale = Math.max(1, Math.abs(s));
+    for (const rawSeed of seeds) {
+        const seed = Math.max(C.Tt, Math.min(REGION4_HS_NEWTON_UPPER, rawSeed));
+        if (!Number.isFinite(seed) || tried.has(seed))
+            continue;
+        tried.add(seed);
+        try {
+            const initialValue = entropyResidualEvaluation(h, s, seed);
+            if (!Number.isFinite(initialValue.quality))
+                continue;
+            const [temperature, quality] = dampedNewton2D(([T, x]) => {
+                const value = entropyResidualEvaluation(h, s, T);
+                const deltaH = value.vaporEnthalpy - value.liquidEnthalpy;
+                const deltaS = value.vaporEntropy - value.liquidEntropy;
+                return {
+                    residual: [
+                        (value.liquidEnthalpy * (1 - x) + value.vaporEnthalpy * x - h) / hScale,
+                        (value.liquidEntropy * (1 - x) + value.vaporEntropy * x - s) / sScale,
+                    ],
+                    jacobian: [
+                        [
+                            (value.liquidDhDT * (1 - x) + value.vaporDhDT * x) / hScale,
+                            deltaH / hScale,
+                        ],
+                        [
+                            (value.liquidDsDT * (1 - x) + value.vaporDsDT * x) / sScale,
+                            deltaS / sScale,
+                        ],
+                    ],
+                };
+            }, [seed, initialValue.quality], {
+                tolerance: 1e-12,
+                maxIterations: 30,
+                isValid: ([T]) => T >= C.Tt && T <= REGION4_HS_NEWTON_UPPER,
+            });
+            if (isAdmissibleQuality(quality)) {
+                const stableTemperature = Math.round(temperature / C.REGION4_TEMPERATURE_TOLERANCE) * C.REGION4_TEMPERATURE_TOLERANCE;
+                const state = finalizeRegion4HSState(h, s, stableTemperature);
+                if (state !== null)
+                    return state;
+            }
+        }
+        catch (error) {
+            if (!(error instanceof IF97Error))
+                throw error;
+        }
+    }
+    return null;
 }
 function finalizeRegion4HSState(h, s, temperature) {
     const endpoints = saturationEndpointsAtTemperature(temperature);
@@ -43,7 +251,9 @@ function finalizeRegion4HSState(h, s, temperature) {
     if (Math.abs(normalizedQualityFromEnthalpy - normalizedQualityFromEntropy) > REGION4_QUALITY_TOLERANCE) {
         return null;
     }
-    if (Math.abs(entropyResidual(h, s, temperature)) > C.REGION4_HS_RESIDUAL_TOLERANCE) {
+    const mixedEntropy = endpoints.liquid.entropy * (1 - qualityFromEnthalpy) +
+        endpoints.vapor.entropy * qualityFromEnthalpy;
+    if (Math.abs(mixedEntropy - s) > C.REGION4_HS_RESIDUAL_TOLERANCE) {
         return null;
     }
     try {
@@ -52,114 +262,73 @@ function finalizeRegion4HSState(h, s, temperature) {
     catch {
         return null;
     }
-    return mixSaturationState(endpoints, normalizedQualityFromEnthalpy);
+    const exactEndpointQuality = endpointQuality(qualityFromEnthalpy, qualityFromEntropy);
+    return mixSaturationState(endpoints, exactEndpointQuality ?? normalizedQualityFromEnthalpy);
 }
-function endpointStateForPhase(h, s, temperature, phase) {
-    let endpoints;
-    try {
-        endpoints = saturationEndpointsAtTemperature(temperature);
-    }
-    catch {
-        return null;
-    }
-    const endpoint = endpoints[phase];
-    if (!isClose(endpoint.enthalpy, h) || !isClose(endpoint.entropy, s)) {
+function isTriplePointHS(h, s) {
+    const { liquid, vapor } = REGION4_TRIPLE_POINT_ENDPOINTS;
+    const quality = rawQualityFromSaturationProperty(liquid.entropy, vapor.entropy, s);
+    if (quality < 0 || quality > 1)
+        return false;
+    const expectedH = liquid.enthalpy * (1 - quality) + vapor.enthalpy * quality;
+    return Math.abs(expectedH - h) <= C.REGION4_HS_RESIDUAL_TOLERANCE;
+}
+function tryRegion4HSBackwardState(h, s) {
+    if (s < REGION4_HS_BACKWARD_MIN_ENTROPY)
         return null;
-    }
-    try {
-        assertRegion4StateAllowed(endpoints.pressure, endpoints.temperature, 'Region4HS');
-    }
-    catch {
+    const lower = C.Tt;
+    const upper = C.R2_T_MIN;
+    const rawSeed = region4BackwardTemperatureHS(h, s);
+    if (!Number.isFinite(rawSeed) || rawSeed < lower - 0.1 || rawSeed > upper + 0.1) {
         return null;
     }
-    return mixSaturationState(endpoints, phase === 'liquid' ? 0 : 1);
-}
-function endpointEnthalpyResidual(h, temperatureGuess, phase) {
-    let endpoints;
-    try {
-        endpoints = saturationEndpointsAtTemperature(clampRegion4TemperatureBelowCritical(temperatureGuess));
-    }
-    catch {
-        return Number.NaN;
-    }
-    return endpoints[phase].enthalpy - h;
-}
-function tryRegion4HSEndpointState(h, s) {
-    const lower = C.Tt;
-    const upper = clampRegion4TemperatureBelowCritical(C.Tc);
-    for (const phase of ['liquid', 'vapor']) {
-        const lowerState = endpointStateForPhase(h, s, lower, phase);
-        if (lowerState !== null) {
-            return lowerState;
-        }
-        const upperState = endpointStateForPhase(h, s, upper, phase);
-        if (upperState !== null) {
-            return upperState;
-        }
-        let previousTemperature = lower;
-        let previousResidual = endpointEnthalpyResidual(h, lower, phase);
-        for (let i = 1; i <= C.REGION4_HS_BRACKET_SEGMENTS; i++) {
-            const temperature = lower + (upper - lower) * (i / C.REGION4_HS_BRACKET_SEGMENTS);
-            const residual = endpointEnthalpyResidual(h, temperature, phase);
-            if (!Number.isFinite(previousResidual) || !Number.isFinite(residual)) {
-                previousTemperature = temperature;
-                previousResidual = residual;
-                continue;
-            }
-            if (isClose(previousResidual, 0)) {
-                return endpointStateForPhase(h, s, previousTemperature, phase);
-            }
-            if (isClose(residual, 0)) {
-                return endpointStateForPhase(h, s, temperature, phase);
-            }
-            if (previousResidual * residual < 0) {
-                const root = bracketedNewton((candidateTemperature) => endpointEnthalpyResidual(h, candidateTemperature, phase), previousTemperature, temperature, (previousTemperature + temperature) / 2, { tolerance: C.REGION4_HS_RESIDUAL_TOLERANCE });
-                return endpointStateForPhase(h, s, root, phase);
-            }
-            previousTemperature = temperature;
-            previousResidual = residual;
+    const seed = Math.max(lower, Math.min(upper, rawSeed));
+    const seedState = finalizeRegion4HSState(h, s, seed);
+    if (seedState !== null)
+        return seedState;
+    let radius = 0.01;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        const bracketLower = Math.max(lower, seed - radius);
+        const bracketUpper = Math.min(upper, seed + radius);
+        const lowerResidual = entropyResidual(h, s, bracketLower);
+        const upperResidual = entropyResidual(h, s, bracketUpper);
+        if (Number.isFinite(lowerResidual) && Number.isFinite(upperResidual) &&
+            lowerResidual * upperResidual <= 0) {
+            let cachedTemperature = Number.NaN;
+            let cachedEvaluation = { residual: Number.NaN, derivative: Number.NaN };
+            const evaluate = (candidateTemperature) => {
+                if (candidateTemperature !== cachedTemperature) {
+                    cachedTemperature = candidateTemperature;
+                    cachedEvaluation = entropyResidualEvaluation(h, s, candidateTemperature);
+                }
+                return cachedEvaluation;
+            };
+            const root = bracketedNewton((candidateTemperature) => evaluate(candidateTemperature).residual, bracketLower, bracketUpper, seed, {
+                tolerance: C.REGION4_HS_RESIDUAL_TOLERANCE,
+                derivative: (candidateTemperature) => evaluate(candidateTemperature).derivative,
+            });
+            return finalizeRegion4HSState(h, s, root);
         }
+        if (bracketLower === lower && bracketUpper === upper)
+            break;
+        radius *= 2;
     }
     return null;
 }
 export function tryRegion4HSState(h, s) {
-    const endpointState = tryRegion4HSEndpointState(h, s);
-    if (endpointState !== null) {
-        return endpointState;
-    }
-    const lower = C.Tt;
-    const upper = clampRegion4TemperatureBelowCritical(C.Tc);
-    const lowerState = finalizeRegion4HSState(h, s, lower);
-    if (lowerState !== null) {
-        return lowerState;
-    }
-    const upperState = finalizeRegion4HSState(h, s, upper);
-    if (upperState !== null) {
-        return upperState;
-    }
-    let previousTemperature = lower;
-    let previousResidual = entropyResidual(h, s, lower);
-    for (let i = 1; i <= C.REGION4_HS_BRACKET_SEGMENTS; i++) {
-        const temperature = lower + (upper - lower) * (i / C.REGION4_HS_BRACKET_SEGMENTS);
-        const residual = entropyResidual(h, s, temperature);
-        if (!Number.isFinite(previousResidual) || !Number.isFinite(residual)) {
-            previousTemperature = temperature;
-            previousResidual = residual;
-            continue;
-        }
-        if (isClose(previousResidual, 0)) {
-            return finalizeRegion4HSState(h, s, previousTemperature);
-        }
-        if (isClose(residual, 0)) {
-            return finalizeRegion4HSState(h, s, temperature);
-        }
-        if (previousResidual * residual < 0) {
-            const root = bracketedNewton((candidateTemperature) => entropyResidual(h, s, candidateTemperature), previousTemperature, temperature, (previousTemperature + temperature) / 2, { tolerance: C.REGION4_HS_RESIDUAL_TOLERANCE });
-            return finalizeRegion4HSState(h, s, root);
-        }
-        previousTemperature = temperature;
-        previousResidual = residual;
+    if (isTriplePointHS(h, s)) {
+        const triplePointState = finalizeRegion4HSState(h, s, C.Tt);
+        if (triplePointState !== null)
+            return triplePointState;
     }
+    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;
 }
-//# sourceMappingURL=region4-hs.js.map

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

@@ -19,4 +19,3 @@ export declare function solvePx(p: number, x: number): BasicProperties;
  * @param x - Vapour quality [0, 1]
  */
 export declare function solveTx(T: number, x: number): BasicProperties;
-//# sourceMappingURL=two-phase.d.ts.map

package/dist/saturation/two-phase.js

@@ -41,4 +41,3 @@ export function solveTx(T, x) {
     const p = normalizeRegion4Pressure(saturationPressure(temperature));
     return solvePx(p, x);
 }
-//# sourceMappingURL=two-phase.js.map

package/dist/saturation.d.ts

@@ -7,4 +7,3 @@
  * critical-point rules.
  */
 export { saturationPressure, saturationTemperature } from './regions/region4.js';
-//# sourceMappingURL=saturation.d.ts.map

package/dist/saturation.js

@@ -7,4 +7,3 @@
  * critical-point rules.
  */
 export { saturationPressure, saturationTemperature } from './regions/region4.js';
-//# sourceMappingURL=saturation.js.map

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

@@ -6,13 +6,15 @@ export interface BracketedNewtonOptions {
     maxIterations?: number;
     /** Relative step size for central-difference derivative (default 1e-6) */
     derivativeStep?: number;
+    /** Optional analytical derivative. */
+    derivative?: (x: number) => number;
 }
 /**
  * Find a root of f(x) = 0 within the bracket [lower, upper].
  *
- * Each iteration attempts a Newton step using a central-difference derivative.
- * If the Newton candidate falls outside the current bracket or the derivative
- * is unavailable, a bisection step is used instead.
+ * 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.
  *
  * @param f            - Continuous function whose root is sought
  * @param lower        - Lower bound of the bracket
@@ -23,4 +25,3 @@ export interface BracketedNewtonOptions {
  * @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;
-//# sourceMappingURL=bracketed-newton.d.ts.map

package/dist/solvers/bracketed-newton.js

@@ -20,9 +20,9 @@ function numericalDerivative(f, x, lower, upper, step) {
 /**
  * Find a root of f(x) = 0 within the bracket [lower, upper].
  *
- * Each iteration attempts a Newton step using a central-difference derivative.
- * If the Newton candidate falls outside the current bracket or the derivative
- * is unavailable, a bisection step is used instead.
+ * 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.
  *
  * @param f            - Continuous function whose root is sought
  * @param lower        - Lower bound of the bracket
@@ -69,9 +69,9 @@ export function bracketedNewton(f, lower, upper, initialGuess, options) {
             return midpoint;
         }
         const step = Math.min(derivativeStep * Math.max(1, Math.abs(x)), (b - a) / 4);
-        const derivative = step > 0
+        const derivative = options?.derivative?.(x) ?? (step > 0
             ? numericalDerivative(f, x, a, b, step)
-            : null;
+            : null);
         const newtonCandidate = derivative === null || !Number.isFinite(derivative) || derivative === 0
             ? NaN
             : x - fx / derivative;
@@ -81,4 +81,3 @@ export function bracketedNewton(f, lower, upper, initialGuess, options) {
     }
     throw new ConvergenceError('bracketedNewton', maxIterations);
 }
-//# sourceMappingURL=bracketed-newton.js.map

package/dist/solvers/damped-newton-2d.d.ts

@@ -0,0 +1,12 @@
+export type Vector2 = readonly [number, number];
+export interface Newton2DEvaluation {
+    residual: Vector2;
+    jacobian: readonly [Vector2, Vector2];
+}
+export interface DampedNewton2DOptions {
+    tolerance?: number;
+    maxIterations?: number;
+    maxBacktracks?: number;
+    isValid?: (point: Vector2) => boolean;
+}
+export declare function dampedNewton2D(evaluate: (point: Vector2) => Newton2DEvaluation, initial: Vector2, options?: DampedNewton2DOptions): [number, number];