Preserve exact NumPy scalar bounds across platforms

Mixed longdouble and Fraction comparisons rejected valid closed endpoints
and raised TypeError for out-of-domain inputs. Compare supported original
floating sources and bounds through their exact integer ratios, reusing the
already represented ratio for native floats. Accepted runtime values still
use binary64; precision is retained only for the admission decision.

Add 14 portable NumPy/rational endpoint, outside-boundary and reversed-bound
controls, while retaining the genuine extended-precision Linux regression.
Focused checks pass locally; the exact-commit Linux matrix verifies the
platform-specific case before release publication.

Author: TNFR AI Agent

docs/API_CONTRACTS.md

@@ -475,7 +475,9 @@ unchecked call does not acquire that certificate.
 Closed scalar configuration intervals use `bounded_represented_real` from
 `_exact_time.py` to check the original admitted source against their bounds.
 An exact value outside the interval cannot enter by rounding to an endpoint;
-accepted values retain the consumer's binary64 model. This boundary applies
+floating sources and bounds exposing exact integer ratios use those ratios
+for comparison, retaining precision beyond binary64 when available.
+Accepted values retain the consumer's binary64 model. This boundary applies
 to selector/adaptation controls, stability fractions and active glyph factors.
 It does not prohibit rounded arithmetic already declared by a numerical model.
 

src/tnfr/_exact_time.py

@@ -76,18 +76,26 @@ def bounded_represented_real(
     """
     result = finite_represented_real(value, label)
 
-    def ordered_source(raw: Any) -> Any:
+    def ordered_source(raw: Any, represented: Fraction) -> Any:
         if isinstance(raw, Rational):
             return Fraction(int(raw.numerator), int(raw.denominator))
+        if type(raw) is float:
+            return represented
+        ratio = getattr(raw, "as_integer_ratio", None)
+        if ratio is not None:
+            # Extended floating scalars need not compare directly with Fraction.
+            # Their source ratio preserves precision beyond the runtime float.
+            numerator, denominator = ratio()
+            return Fraction(int(numerator), int(denominator))
         return raw
 
-    source = ordered_source(value)
+    source = ordered_source(value, result[1])
     if minimum is not None:
-        finite_represented_real(minimum, f"{label} lower bound")
-        minimum = ordered_source(minimum)
+        _, exact_minimum = finite_represented_real(minimum, f"{label} lower bound")
+        minimum = ordered_source(minimum, exact_minimum)
     if maximum is not None:
-        finite_represented_real(maximum, f"{label} upper bound")
-        maximum = ordered_source(maximum)
+        _, exact_maximum = finite_represented_real(maximum, f"{label} upper bound")
+        maximum = ordered_source(maximum, exact_maximum)
     if minimum is not None and maximum is not None and minimum > maximum:
         raise ValueError(f"{label} lower bound must not exceed its upper bound")
     if minimum is not None and source < minimum:

tests/test_bounded_scalar_admission.py

@@ -65,6 +65,59 @@ def test_fixed_width_fraction_components_do_not_overflow_original_domain_checks(
             bounded_represented_real(value, "ratio", minimum=bound, maximum=value)
 
 
+@pytest.mark.parametrize(
+    "value,minimum,maximum",
+    [
+        (np.longdouble(0), Fraction(0), Fraction(1)),
+        (np.longdouble(1), Fraction(0), Fraction(1)),
+        (np.longdouble(0.5), Fraction(1, 2), Fraction(1, 2)),
+        (Fraction(1, 2), np.longdouble(0.5), np.longdouble(0.5)),
+        (np.longdouble(0.5), np.longdouble(0), Fraction(1)),
+        (np.longdouble(0.5), Fraction(0), np.longdouble(1)),
+        (0.5, np.longdouble(0.5), Fraction(1, 2)),
+    ],
+)
+def test_numpy_real_and_rational_bounds_admit_exact_endpoints(value, minimum, maximum):
+    actual, exact = bounded_represented_real(
+        value, "ratio", minimum=minimum, maximum=maximum
+    )
+    assert actual == float(value)
+    assert exact == Fraction.from_float(actual)
+
+
+@pytest.mark.parametrize(
+    "value,minimum,maximum",
+    [
+        (np.longdouble(1), 0, Fraction(1) - Fraction(1, 2**100)),
+        (np.longdouble(1), _BEYOND_ONE, 2),
+        (_BEYOND_ONE, 0, np.longdouble(1)),
+        (Fraction(1) - Fraction(1, 2**100), np.longdouble(1), 2),
+        (np.longdouble(-1), Fraction(-1) + Fraction(1, 2**100), 0),
+    ],
+)
+def test_numpy_real_and_rational_bounds_reject_exact_outside_values(
+    value, minimum, maximum
+):
+    # The source or bound differs from its adjacent endpoint below binary64
+    # resolution, including on platforms where longdouble itself is binary64.
+    with pytest.raises(ValueError, match="ratio must be"):
+        bounded_represented_real(value, "ratio", minimum=minimum, maximum=maximum)
+
+
+@pytest.mark.parametrize(
+    "minimum,maximum",
+    [
+        (np.longdouble(1), Fraction(1) - Fraction(1, 2**100)),
+        (_BEYOND_ONE, np.longdouble(1)),
+    ],
+)
+def test_numpy_real_and_rational_bounds_reject_exact_reversed_interval(
+    minimum, maximum
+):
+    with pytest.raises(ValueError, match="lower bound"):
+        bounded_represented_real(1, "ratio", minimum=minimum, maximum=maximum)
+
+
 def test_higher_precision_real_is_not_rounded_into_the_unit_interval():
     source = np.nextafter(np.longdouble(1), np.longdouble(2))
     if source == np.longdouble(float(source)):