gcf-python 2.5.3__tar.gz → 2.6.0__tar.gz

{gcf_python-2.5.3 → gcf_python-2.6.0}/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v2.6.0 (2026-08-14)
+
+- **Numeric domain (spec v3.5.3, SPEC 2.3.2).** Specifies the canonical numeric domain as signed `int64` for integers and IEEE-754 double for non-integers. Earlier versions left integers beyond the double-exact range (2^53) to the host numeric type; this version parses integer literals to an exact `int64` on decode and on the JSON-to-value bridge, returns an out-of-range error for a value outside `int64` on both decode and encode, and models larger values (unsigned-64 identifiers, exact decimals) as strings. Canonical number formatting aligns to the domain: a double at or above 2^53 renders in exponent notation. Verified against new `numbers/017-024` and `errors-v2/041-042` conformance fixtures and the cross-SDK differential fuzz. An out-of-range value raises `ValueError`.
+
 ## v2.5.3 (2026-08-10)
 
 - **Losslessness fix (spec v3.5.2, SPEC 2.3/2.4).** The number grammar and numeric-like classification now pin digits to ASCII `[0-9]`. Python's `re` compiles `\d` in Unicode mode (matching `\p{Nd}`), so a value like `1.٥` (ASCII `1`, `.`, U+0665) was treated as number-shaped: quoted on encode, and a bare `1.٥` decoded through `float()` to the number `1.5`. That diverged from the ASCII SDKs and silently turned a string into a number when decoding wire produced by another SDK. `\d` is replaced with `[0-9]`; such tokens stay strings and encode bare. Verified against new `scalar/029-031` and `decode/007` conformance fixtures and the cross-SDK differential fuzz.

{gcf_python-2.5.3 → gcf_python-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: gcf-python
-Version: 2.5.3
+Version: 2.6.0
 Summary: The AI-native wire format for structured data. 50-92% fewer tokens than JSON, with multi-turn delta encoding for agent loops. 100% comprehension on every frontier model. Zero dependencies.
 Project-URL: Homepage, https://github.com/blackwell-systems/gcf-python
 Project-URL: Documentation, https://gcformat.com/

{gcf_python-2.5.3 → gcf_python-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gcf-python"
-version = "2.5.3"
+version = "2.6.0"
 description = "The AI-native wire format for structured data. 50-92% fewer tokens than JSON, with multi-turn delta encoding for agent loops. 100% comprehension on every frontier model. Zero dependencies."
 readme = "README.md"
 license = {text = "MIT"}

{gcf_python-2.5.3 → gcf_python-2.6.0}/src/gcf/__init__.py

@@ -102,4 +102,4 @@ __all__ = [
     "DEFAULT_REANCHOR_N",
 ]
 
-__version__ = "2.3.0"
+__version__ = "2.6.0"

{gcf_python-2.5.3 → gcf_python-2.6.0}/src/gcf/scalar.py

@@ -93,6 +93,15 @@ def format_scalar(v: Any, delimiter: str = "") -> str:
     if isinstance(v, bool):
         return "true" if v else "false"
     if isinstance(v, int) and not isinstance(v, bool):
+        # The encoder enforces the int64 domain (SPEC 2.3.2): a Python int is
+        # arbitrary-precision, so a host integer outside int64 is rejected here
+        # rather than emitted as a bare token the decoder would reject.
+        if v < -(2**63) or v > 2**63 - 1:
+            raise ValueError(
+                f"out_of_range: integer {v} is outside the canonical int64 "
+                "domain [-9223372036854775808, 9223372036854775807]; "
+                "model larger values as strings (SPEC 2.3.2)"
+            )
         return str(v)
     if isinstance(v, float):
         return format_number(v)
@@ -111,7 +120,12 @@ def format_number(f: float) -> str:
         # Negative zero canonicalizes to 0 (SPEC 2.3.1): -0.0 equals 0.0 by value.
         return "0"
     a = abs(f)
-    if 1e-6 <= a < 1e21:
+    # Plain decimal only below 2^53. Every double at or above 2^53 is integer-valued,
+    # so a plain rendering would emit a bare-integer token: indistinguishable from an
+    # int64 on the wire and beyond the binary64 safe-integer range (2^53-1), so a
+    # JavaScript decoder rejects it under its default policy. Exponent shape keeps bare
+    # tokens int64 and decimal/exponent tokens doubles (SPEC 2.3.1). Ints format above.
+    if 1e-6 <= a < 2**53:
         # Use repr for shortest round-trippable form.
         s = repr(f)
         # If repr chose scientific notation, convert to plain decimal.
@@ -165,12 +179,20 @@ def parse_scalar(s: str, tabular_context: bool = False) -> Any:
     if s == "false":
         return False
     if _JSON_NUMBER_RE.match(s):
+        # Token shape follows domain (SPEC 2.3.2): a bare-integer literal (no
+        # fraction, no exponent) is an int64-domain integer parsed exactly, not
+        # routed through float(); a decimal or exponent literal is a double.
+        if "." not in s and "e" not in s and "E" not in s:
+            n = int(s)
+            if n < -(2**63) or n > 2**63 - 1:
+                raise ValueError(
+                    f"out_of_range: integer {s} is outside the canonical int64 "
+                    "domain [-9223372036854775808, 9223372036854775807]; "
+                    "model larger values as strings (SPEC 2.3.2)"
+                )
+            return n
         try:
-            f = float(s)
-            if "." not in s and "e" not in s and "E" not in s:
-                if abs(f) <= 2**53:
-                    return int(f)
-            return f
+            return float(s)
         except ValueError:
             pass
     return s

{gcf_python-2.5.3 → gcf_python-2.6.0}/tests/test_conformance_v2.py

@@ -183,6 +183,23 @@ def test_conformance(rel_path, data):
         with pytest.raises((ValueError, Exception)):
             decode_generic(data["input"])
 
+    elif op == "roundtrip-wire":
+        # Input and expected are wire strings: decode then re-encode and require the
+        # result to equal the input wire. The value never becomes a host number, so a
+        # value that a JSON parser would float (an integer beyond 2^53) is pinned here.
+        decoded = decode_generic(data["input"])
+        reencoded = encode_generic(decoded)
+        assert reencoded == data["expected"], (
+            f"wire idempotence mismatch:\n  got: {reencoded!r}\n  exp: {data['expected']!r}"
+        )
+
+    elif op == "encode-error":
+        # Input is a JSON value (encode-side) out of the numeric domain; encoding it
+        # must raise. In Python the JSON parser preserves big integers exactly, so the
+        # encoder is the domain-enforcement site.
+        with pytest.raises((ValueError, Exception)):
+            encode_generic(data["input"])
+
     elif op == "generic-pack-root":
         from gcf.generic_delta import GenericSet, generic_pack_root