sidereon 3.0.0__tar.gz → 3.0.2__tar.gz

{sidereon-3.0.0 → sidereon-3.0.2}/.github/workflows/release.yml

@@ -153,10 +153,10 @@ jobs:
             done
             for source in mod.rs ocean.rs pole.rs; do
               unzip -p "$wheel" \
-                "third_party_source/sidereon-core-3.0.0/tides/$source" \
+                "third_party_source/sidereon-core-3.0.2/tides/$source" \
                 >"$RUNNER_TEMP/$source"
               cmp "$RUNNER_TEMP/$source" \
-                "third_party_source/sidereon-core-3.0.0/tides/$source"
+                "third_party_source/sidereon-core-3.0.2/tides/$source"
             done
           done
           notice="$RUNNER_TEMP/sdist.notices"
@@ -173,10 +173,10 @@ jobs:
           done
           for source in mod.rs ocean.rs pole.rs; do
             tar -xOf "${sdists[0]}" --wildcards \
-              "*/third_party_source/sidereon-core-3.0.0/tides/$source" \
+              "*/third_party_source/sidereon-core-3.0.2/tides/$source" \
               >"$RUNNER_TEMP/sdist-$source"
             cmp "$RUNNER_TEMP/sdist-$source" \
-              "third_party_source/sidereon-core-3.0.0/tides/$source"
+              "third_party_source/sidereon-core-3.0.2/tides/$source"
           done
       - name: Smoke-test installed x86_64 Linux wheel
         shell: bash
@@ -218,3 +218,39 @@ jobs:
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           attestations: true
+
+  public-consumer:
+    name: Verify public PyPI consumer
+    runs-on: ubuntu-24.04-arm
+    timeout-minutes: 15
+    needs: publish
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install exact published wheel and exercise public references
+        shell: bash
+        run: |
+          set -euo pipefail
+          version="${GITHUB_REF_NAME#v}"
+          scratch="$(mktemp -d)"
+          trap 'rm -rf "$scratch"' EXIT
+          python -m venv "$scratch/venv"
+          installed=false
+          for attempt in 1 2 3 4 5 6; do
+            if "$scratch/venv/bin/python" -m pip install --only-binary=sidereon "sidereon==$version" pytest; then
+              installed=true
+              break
+            fi
+            sleep 10
+          done
+          test "$installed" = true
+          mkdir -p "$scratch/tests/fixtures/bodies"
+          cp scripts/smoke-release.py "$scratch/smoke-release.py"
+          cp tests/test_body_observe_reference.py "$scratch/tests/"
+          cp tests/fixtures/bodies/observe_de.bsp "$scratch/tests/fixtures/bodies/"
+          cd "$scratch"
+          unset PYTHONPATH
+          SIDEREON_EXPECTED_VERSION="$version" "$scratch/venv/bin/python" -I smoke-release.py
+          "$scratch/venv/bin/python" -I -m pytest -q tests/test_body_observe_reference.py

{sidereon-3.0.0 → sidereon-3.0.2}/CHANGELOG.md

@@ -2,7 +2,26 @@
 
 All notable changes to the Sidereon Python interface are documented here.
 
-## [3.0.0]
+## [Unreleased]
+
+## [3.0.2] - 2026-10-05
+
+### Changed
+
+- Use the coordinated 3.0.2 Rust engine release, including NaN-safe Portable ULP comparisons.
+- Retain the existing Python API while keeping package versions and shipped source disclosures aligned across all libraries.
+
+## [3.0.1] - 2026-10-04
+
+### Added
+
+- Opt-in `acquire(..., http_client_exception_diagnostics=callback)` reports
+  the class and bounded module/function metadata of unexpected exceptions
+  from caller-supplied HTTP transports. Diagnostics omit messages, arguments,
+  URLs and request/response data; observer failures leave the original terminal
+  exception unchanged.
+
+## [3.0.0] - 2026-10-04
 
 ### Added
 
@@ -70,7 +89,7 @@ All notable changes to the Sidereon Python interface are documented here.
 - `Sp3MergeOptions` no longer refuses a `target_epoch_interval_s` that is not a whole number of seconds. The merge takes any interval a whole number of 10-nanosecond ticks states and the core refuses the rest; the persisted merge-input identity still binds whole seconds only, and the core refuses a fractional interval there.
 - **Breaking.** The robust (Huber) reweighting runs until it settles: `SPP_DEFAULT_ROBUST_MAX_OUTER`, the default `SppRobustConfig.max_outer`, is 100 instead of 5, a safeguard rather than a working budget. A reweighting that cycles stops with the new status `outer_oscillation`.
 
-- Engine update: sidereon and sidereon-core 3.0.0, at core revision `2373644611953e1833c0deb94057acc34bcec973`. Every core breaking change below reaches Python as the core states it; the core CHANGELOG gives the reason for each.
+- Engine update: sidereon and sidereon-core 3.0.0, at core revision `e2fb3dfdc392d23087ed8aa1ee028a0056b4021b`. Every core breaking change below reaches Python as the core states it; the core CHANGELOG gives the reason for each.
 - **Breaking.** `NmeaDiagnostics.skips` and `warnings` are lists of `FormatSkip` and `FormatWarning` instead of strings, and `NmeaDiagnostics` is `FormatDiagnostics`.
 - **Breaking.** `BiasSet.code_osb_seconds`, `phase_osb_cycles`, `code_dsb_seconds` and `code_bias_model_m` return a `BiasLookup` whose `status` names the outcome (`available`, `absent`, `unsupported_scale`, `ambiguous`, `carrier_frequency_required`, `invalid_carrier_frequency`, `carrier_frequency_unknown`, `undefined_slope_reference`, `invalid_epoch`) instead of a float or `None`. A phase bias stated in nanoseconds needs `carrier_hz`. `BiasSet.time_scale` is `None` for a product with no usable time scale, and a lookup on such a product needs `time_scale`. `BiasRecord.is_phase` follows the observable code, so a phase bias stated in nanoseconds is a phase bias.
 - **Breaking.** The Bias-SINEX readers are strict by default and raise `ValueError` for a file that departs from Bias-SINEX 1.00 or states another version; `BiasReadPolicy.LENIENT` reads it and reports each departure in `BiasSet.notices`. A CODE DCB title whose time-system label names no known scale is refused likewise.

{sidereon-3.0.0 → sidereon-3.0.2}/Cargo.lock

@@ -611,9 +611,9 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sidereon"
-version = "3.0.0"
+version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83ff5c00bdcbd35203e3bfc34dfcd6c08783d522f1163b64e45dceb31d61fc69"
+checksum = "8a424bd9dea809b4cf2b816c27aa129a3e437b95139389ecbc94416aeee27951"
 dependencies = [
  "crc32fast",
  "flate2",
@@ -622,9 +622,9 @@ dependencies = [
 
 [[package]]
 name = "sidereon-core"
-version = "3.0.0"
+version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2f968098493ebfd6694cc318f4a4d15df5933342e0bbd1210dbc46c176d3994"
+checksum = "29f682ba7089c512d83cfea712bdc6ce9caac5e46d9acbeca7a1b2151ad8ee5b"
 dependencies = [
  "approx",
  "cc",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "sidereon-py"
-version = "3.0.0"
+version = "3.0.2"
 dependencies = [
  "nalgebra",
  "numpy",

{sidereon-3.0.0 → sidereon-3.0.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sidereon-py"
-version = "3.0.0"
+version = "3.0.2"
 authors = []
 edition = "2021"
 description = "Python (PyO3) bindings over the sidereon ergonomic API: SP3 loading and SPP/RTK/PPP positioning solves"
@@ -25,12 +25,12 @@ exact-cache-test-failpoints = ["sidereon-core/exact-cache-test-failpoints"]
 # The thin ergonomic engine surface this binding marshals to. No modeling logic
 # lives here: every solve delegates to a `sidereon` entry point, which in turn
 # delegates to `sidereon-core`.
-sidereon = { version = "=3.0.0" }
-sidereon-core = { version = "=3.0.0", features = ["mmap"] }
+sidereon = "=3.0.2"
+sidereon-core = { version = "=3.0.2", features = ["mmap"] }
 # The standalone general-purpose trust-region least-squares solver: a data-driven
 # `least_squares` whose residual and Jacobian are evaluated entirely in Rust, so
 # no per-iteration Python callback is paid.
-trust-region-least-squares = "0.11.0"
+trust-region-least-squares = "=0.11.0"
 pyo3 = { version = "0.25", features = ["abi3-py39"] }
 # Zero-copy ndarray marshalling so a batched propagate/look-angle call crosses
 # the FFI boundary once (1-D epochs in, 2-D states / 1-D angles out) instead of a

{sidereon-3.0.0 → sidereon-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sidereon
-Version: 3.0.0
+Version: 3.0.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering

{sidereon-3.0.0 → sidereon-3.0.2}/THIRD-PARTY-NOTICES.md

@@ -330,8 +330,10 @@ endorsed by the IERS Conventions Center. The Rust source describes the origin,
 the renamed routines, and the differences from the Fortran implementation.
 The complete non-test tide source distributed in the compiled extension is
 included under
-`third_party_source/sidereon-core-3.0.0/tides/` in wheels and source
-distributions. The authoritative original is available from:
+`third_party_source/sidereon-core-3.0.2/tides/` in wheels and source
+distributions. These files match sidereon-core 3.0.2 at commit 8694648892d8ab065d94014e2e21d6cd5054818e.
+Source: [sidereon-core tides at the pinned commit](https://github.com/neilberkman/sidereon/tree/8694648892d8ab065d94014e2e21d6cd5054818e/crates/sidereon-core/src/tides).
+The authoritative original is available from:
 
 <https://iers-conventions.obspm.fr/content/chapter7/software/dehanttideinel/DEHANTTIDEINEL.F>
 

{sidereon-3.0.0 → sidereon-3.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sidereon"
-version = "3.0.0"
+version = "3.0.2"
 description = "Python (PyO3) bindings over the sidereon engine: SP3 loading and SPP/RTK/PPP positioning solves"
 readme = "README.md"
 license = { text = "MIT" }
@@ -82,7 +82,7 @@ include = [
   "third_party_licenses/ERFA-BSD-3-Clause.txt",
   "third_party_licenses/IERS-CONVENTIONS-SOFTWARE-LICENSE.txt",
   "third_party_licenses/SciPy-BSD-3-Clause.txt",
-  "third_party_source/sidereon-core-3.0.0/tides/mod.rs",
-  "third_party_source/sidereon-core-3.0.0/tides/ocean.rs",
-  "third_party_source/sidereon-core-3.0.0/tides/pole.rs",
+  "third_party_source/sidereon-core-3.0.2/tides/mod.rs",
+  "third_party_source/sidereon-core-3.0.2/tides/ocean.rs",
+  "third_party_source/sidereon-core-3.0.2/tides/pole.rs",
 ]

{sidereon-3.0.0 → sidereon-3.0.2}/python/sidereon/__init__.py

@@ -3213,4 +3213,4 @@ try:
 
     __version__ = _pkg_version("sidereon")
 except Exception:  # package metadata unavailable (e.g. running from a source tree)
-    __version__ = "3.0.0"
+    __version__ = "3.0.1"

{sidereon-3.0.0 → sidereon-3.0.2}/python/sidereon/distribution.py

@@ -16,10 +16,11 @@ import json
 import netrc
 import os
 import time
+from collections import deque
 from dataclasses import asdict, dataclass, field, replace
 from enum import Enum
 from pathlib import Path
-from typing import Mapping, Optional, Sequence, Tuple, Union, cast
+from typing import Callable, Mapping, Optional, Sequence, Tuple, Union, cast
 from urllib.parse import urljoin, urlsplit, urlunsplit
 
 import httpx
@@ -660,8 +661,19 @@ def acquire(
     max_archive_bytes: int = _DEFAULT_MAX_ARCHIVE_BYTES,
     max_product_bytes: int = _DEFAULT_MAX_PRODUCT_BYTES,
     http_client: Optional[httpx.Client] = None,
+    http_client_exception_diagnostics: Optional[
+        Callable[[Mapping[str, object]], None]
+    ] = None,
 ) -> AcquiredProduct:
-    """Acquire the exact product from only the ordered allowed distributors."""
+    """Acquire an exact product from the ordered distributors.
+
+    When a caller-supplied HTTP transport raises an unexpected exception, the
+    optional diagnostic callback receives only the exception class, a client
+    callsite, and up to eight module/function/arity frames. Exception messages,
+    arguments, URLs, headers, and response bodies are omitted. The original
+    exception is re-raised unchanged, and callback failures are ignored.
+    Payload keys are ``exception_class``, ``client_callsite`` and ``stack_frames``.
+    """
     return _acquire_impl(
         exact_request,
         cache_dir=cache_dir,
@@ -675,6 +687,7 @@ def acquire(
         max_archive_bytes=max_archive_bytes,
         max_product_bytes=max_product_bytes,
         http_client=http_client,
+        http_client_exception_diagnostics=http_client_exception_diagnostics,
         direct_location=None,
     )
 
@@ -706,6 +719,9 @@ def _acquire_impl(
     max_archive_bytes: int = _DEFAULT_MAX_ARCHIVE_BYTES,
     max_product_bytes: int = _DEFAULT_MAX_PRODUCT_BYTES,
     http_client: Optional[httpx.Client] = None,
+    http_client_exception_diagnostics: Optional[
+        Callable[[Mapping[str, object]], None]
+    ] = None,
     direct_location: Optional[tuple[str, str]],
 ) -> AcquiredProduct:
     _validate_requested_identity(exact_request.identity)
@@ -779,6 +795,7 @@ def _acquire_impl(
                             max_archive_bytes,
                             max_product_bytes,
                             http_client,
+                            http_client_exception_diagnostics,
                             attempts,
                             exact_cache,
                             direct_location,
@@ -850,6 +867,7 @@ def _acquire_one(
     max_archive_bytes: int,
     max_product_bytes: int,
     http_client: Optional[httpx.Client],
+    http_client_exception_diagnostics: Optional[Callable[[Mapping[str, object]], None]],
     attempts: Sequence[SourceFailure],
     exact_cache: _exact_cache.ExactCache,
     direct_location: Optional[tuple[str, str]],
@@ -871,6 +889,7 @@ def _acquire_one(
             backoff_s,
             max_archive_bytes,
             http_client,
+            http_client_exception_diagnostics,
         )
         archive = download.archive
     elif source is DistributionSource.NASA_CDDIS:
@@ -885,6 +904,7 @@ def _acquire_one(
             backoff_s,
             max_archive_bytes,
             http_client,
+            http_client_exception_diagnostics,
         )
         archive = download.archive
     elif source is DistributionSource.LOCAL_FILE:
@@ -1081,6 +1101,7 @@ def _download_http(
     backoff_s: float,
     max_bytes: int,
     supplied_client: Optional[httpx.Client],
+    http_client_exception_diagnostics: Optional[Callable[[Mapping[str, object]], None]],
 ) -> _Download:
     last_error: Optional[AcquisitionError] = None
     if urlsplit(original_url).scheme == "ftp":
@@ -1100,7 +1121,17 @@ def _download_http(
         for attempt in range(retries):
             try:
                 return _download_http_once(
-                    client, original_url, source, auth, timeout_s, max_bytes
+                    client,
+                    original_url,
+                    source,
+                    auth,
+                    timeout_s,
+                    max_bytes,
+                    (
+                        http_client_exception_diagnostics
+                        if supplied_client is not None
+                        else None
+                    ),
                 )
             except AcquisitionError as error:
                 last_error = error
@@ -1114,6 +1145,34 @@ def _download_http(
             client.close()
 
 
+def _http_client_exception_diagnostic(error: Exception) -> Mapping[str, object]:
+    """Return bounded exception metadata without reading message or arguments."""
+    exception_type = type(error)
+    class_name = f"{exception_type.__module__}.{exception_type.__qualname__}"[:256]
+    frames: deque[tuple[str, str, int]] = deque(maxlen=8)
+    traceback = error.__traceback__
+    while traceback is not None:
+        frame = traceback.tb_frame
+        module = frame.f_globals.get("__name__", "")
+        module_name = module[:256] if isinstance(module, str) else ""
+        function_name = frame.f_code.co_name[:256]
+        frames.append((module_name, function_name, frame.f_code.co_argcount))
+        traceback = traceback.tb_next
+    stack_frames = tuple(frames)
+    caller_frames = [
+        frame
+        for frame in stack_frames
+        if not frame[0].startswith("httpx.")
+        and frame[0] not in {"contextlib", __name__}
+    ]
+    callsite = caller_frames[-1] if caller_frames else ("", "", 0)
+    return {
+        "exception_class": class_name,
+        "client_callsite": callsite,
+        "stack_frames": stack_frames,
+    }
+
+
 def _download_http_once(
     client: httpx.Client,
     original_url: str,
@@ -1121,6 +1180,7 @@ def _download_http_once(
     auth: EarthdataAuth,
     timeout_s: float,
     max_bytes: int,
+    http_client_exception_diagnostics: Optional[Callable[[Mapping[str, object]], None]],
 ) -> _Download:
     current = original_url
     for redirect_count in range(_MAX_REDIRECTS + 1):
@@ -1208,6 +1268,15 @@ def _download_http_once(
             raise TransportFailure("connection", current) from None
         except httpx.RequestError:
             raise TransportFailure("other", current) from None
+        except Exception as error:  # noqa: BLE001 - caller transports may raise arbitrary errors
+            if http_client_exception_diagnostics is not None:
+                try:
+                    diagnostic = _http_client_exception_diagnostic(error)
+                    if diagnostic["client_callsite"] != ("", "", 0):
+                        http_client_exception_diagnostics(diagnostic)
+                except BaseException:  # noqa: BLE001 - diagnostics never mask the transport
+                    pass
+            raise
     raise RedirectPolicyFailure(f"too many redirects for {_sanitize_url(original_url)}")
 
 

{sidereon-3.0.0 → sidereon-3.0.2}/python/sidereon/distribution.pyi

@@ -4,7 +4,7 @@ import datetime as dt
 import enum
 import os
 from dataclasses import dataclass
-from typing import Mapping, Optional, Sequence, Tuple, Union
+from typing import Callable, Mapping, Optional, Sequence, Tuple, Union
 
 import httpx
 
@@ -185,6 +185,9 @@ def acquire(
     max_archive_bytes: int = ...,
     max_product_bytes: int = ...,
     http_client: Optional[httpx.Client] = ...,
+    http_client_exception_diagnostics: Optional[
+        Callable[[Mapping[str, object]], None]
+    ] = ...,
 ) -> AcquiredProduct: ...
 
 __all__: list[str]

{sidereon-3.0.0 → sidereon-3.0.2}/scripts/check-release.py

@@ -13,6 +13,7 @@ import tomllib
 ROOT = Path(__file__).resolve().parents[1]
 CORE_GIT_URL = "https://github.com/neilberkman/sidereon"
 FULL_GIT_REVISION = re.compile(r"^[0-9a-f]{40}$")
+CORE_SOURCE_REVISION = "8694648892d8ab065d94014e2e21d6cd5054818e"
 
 
 def registry_version(name, value, package_version):
@@ -113,7 +114,7 @@ def validate_trust_region_dependency(
     value, engine_dependencies, package_version, *, allow_candidate
 ):
     """Accept the registry release or its exact coordinated Git candidate."""
-    if value == "0.11.0":
+    if value in ("0.11.0", "=0.11.0"):
         return
     if not allow_candidate:
         raise ValueError(
@@ -308,7 +309,7 @@ def main() -> None:
         "ocean.rs": "25946677944425671a92717860ac2d70f255de5403eeb1fbf98b361716821d5c",
         "pole.rs": "b4cc4c16bdd8ce1d8f04073602ab47dfb85a002b946ab192e8d4d2d600f0a1f8",
     }
-    tide_root = ROOT / "third_party_source" / "sidereon-core-3.0.0" / "tides"
+    tide_root = ROOT / "third_party_source" / "sidereon-core-3.0.2" / "tides"
     for filename, expected_digest in tide_sources.items():
         source = tide_root / filename
         if not source.is_file():
@@ -317,7 +318,8 @@ def main() -> None:
         if digest != expected_digest:
             raise SystemExit(
                 f"IERS-derived source disclosure {source} has digest {digest}, "
-                f"expected {expected_digest} from sidereon-core 3.0.0"
+                f"expected {expected_digest} from sidereon-core 3.0.2 at "
+                f"{CORE_SOURCE_REVISION}"
             )
 
     if args.tag is not None and args.tag != f"v{python_version}":

{sidereon-3.0.0 → sidereon-3.0.2}/scripts/core_source_identity.rs

@@ -8,7 +8,7 @@ use std::path::{Path, PathBuf};
 
 const REGISTRY_SOURCE: &str = "registry+https://github.com/rust-lang/crates.io-index";
 const GIT_SOURCE_PREFIX: &str = "git+https://github.com/neilberkman/sidereon?rev=";
-const RELEASE_VERSION: &str = "3.0.0";
+const RELEASE_VERSION: &str = "3.0.2";
 
 #[derive(Debug)]
 struct LockedPackage {
@@ -343,7 +343,7 @@ mod tests {
             NEXT_TEMP.fetch_add(1, Ordering::Relaxed)
         ));
         let cache = temp.join("registry/cache/test-index");
-        let extracted = temp.join("registry/src/test-index/sidereon-3.0.0");
+        let extracted = temp.join("registry/src/test-index/sidereon-3.0.1");
         fs::create_dir_all(&cache).expect("create registry cache");
         fs::create_dir_all(&extracted).expect("create extracted source");
         fs::write(
@@ -355,17 +355,17 @@ mod tests {
         let revision = "0123456789abcdef0123456789abcdef01234567";
         let archive = crate_archive(
             "sidereon",
-            "3.0.0",
-            "[package]\nname = \"sidereon\"\nversion = \"3.0.0\"\n",
+            "3.0.1",
+            "[package]\nname = \"sidereon\"\nversion = \"3.0.1\"\n",
             &format!(r#"{{"git":{{"sha1":"{revision}","dirty":false}}}}"#),
         );
         let checksum = format!("{:x}", Sha256::digest(&archive));
-        fs::write(cache.join("sidereon-3.0.0.crate"), archive).expect("write crate archive");
+        fs::write(cache.join("sidereon-3.0.1.crate"), archive).expect("write crate archive");
         assert_eq!(
-            registry_revision(&temp, "sidereon", "3.0.0", &checksum).unwrap(),
+            registry_revision(&temp, "sidereon", "3.0.1", &checksum).unwrap(),
             revision
         );
-        assert!(registry_revision(&temp, "sidereon", "3.0.0", &"f".repeat(64)).is_err());
+        assert!(registry_revision(&temp, "sidereon", "3.0.1", &"f".repeat(64)).is_err());
         fs::remove_dir_all(temp).expect("remove registry test directory");
     }
 

{sidereon-3.0.0 → sidereon-3.0.2}/tests/fixtures/core_goldens.json

@@ -1,6 +1,6 @@
 {
   "source": "scripts/core_goldens",
-  "core_revision": "e2fb3dfdc392d23087ed8aa1ee028a0056b4021b",
+  "core_revision": "8694648892d8ab065d94014e2e21d6cd5054818e",
   "spp_trace_default": {
     "position_m": [
       "0x41511b0a63f49487",

{sidereon-3.0.0 → sidereon-3.0.2}/tests/fixtures/ppp_esbc.json

@@ -16520,5 +16520,5 @@
       ]
     }
   },
-  "core_revision": "e2fb3dfdc392d23087ed8aa1ee028a0056b4021b"
+  "core_revision": "8694648892d8ab065d94014e2e21d6cd5054818e"
 }

sidereon-3.0.2/tests/test_antex_public_equality.py

@@ -0,0 +1,166 @@
+"""Direct equality coverage for public ANTEX values and parse details."""
+
+import sidereon
+
+
+def _record(content, label):
+    assert len(content) <= 60
+    return f"{content:<60}{label}"
+
+
+def _antex(
+    *,
+    version="1.4",
+    system="M",
+    header_comment="header note",
+    pcv_type="R",
+    reference_type="AOAD/M_T",
+    reference_serial="",
+    outer_comment="outside note",
+    grid="     0.0  10.0   5.0",
+    calibration_date="01-JAN-20",
+    pco="      1.00      2.00      3.00",
+    rms_pco="      0.10      0.20      0.30",
+    sample="   NOAZI    1.00    2.00    3.00",
+):
+    """Return a valid, small ANTEX document with all nested value types."""
+    pcv_record = f"{pcv_type:<1}{'':19}{reference_type:<20}{reference_serial:<20}"
+    calibration = f"{'FIELD':<20}{'IGS':<20}{2:6d}{'':4}{calibration_date:<10}"
+    lines = [
+        _record(f"     {version:<3}            {system}", "ANTEX VERSION / SYST"),
+        _record(pcv_record, "PCV TYPE / REFANT"),
+        _record(header_comment, "COMMENT"),
+        _record("", "END OF HEADER"),
+        _record(outer_comment, "COMMENT"),
+        _record("", "START OF ANTENNA"),
+        _record(f"{'TESTANT':<20}{'SERIAL-1':<20}", "TYPE / SERIAL NO"),
+        _record(calibration, "METH / BY / # / DATE"),
+        _record("     1", "# OF FREQUENCIES"),
+        _record(grid, "ZEN1 / ZEN2 / DZEN"),
+        _record("   G01", "START OF FREQUENCY"),
+        _record(pco, "NORTH / EAST / UP"),
+        sample,
+        _record("   G01", "END OF FREQUENCY"),
+        _record("   G01", "START OF FREQ RMS"),
+        _record(rms_pco, "NORTH / EAST / UP"),
+        _record("   NOAZI    0.01    0.02    0.03", ""),
+        _record("   G01", "END OF FREQ RMS"),
+        _record("", "END OF ANTENNA"),
+        _record("after block", "COMMENT"),
+    ]
+    return ("\n".join(lines) + "\n").encode("ascii")
+
+
+def _invalid_pcv_type(value):
+    text = "\n".join(
+        [
+            _record("     1.4            M", "ANTEX VERSION / SYST"),
+            _record(value, "PCV TYPE / REFANT"),
+            _record("", "END OF HEADER"),
+        ]
+    )
+    try:
+        sidereon.load_antex(text.encode("ascii"))
+    except sidereon.AntexParseError as error:
+        assert error.detail is not None
+        return error.detail
+    raise AssertionError("invalid PCV type unexpectedly parsed")
+
+
+def _assert_eq_and_ne(equal_left, equal_again, different):
+    # These wrappers define __eq__ but rely on Python's normal __ne__ fallback.
+    assert equal_left == equal_again
+    assert not (equal_left != equal_again)
+    assert equal_left != different
+    assert not (equal_left == different)
+
+
+def test_public_antex_value_and_error_detail_equality_protocol():
+    source = _antex()
+    parsed = sidereon.load_antex(source)
+    repeated = sidereon.load_antex(source)
+
+    header_changed = sidereon.load_antex(_antex(header_comment="changed header"))
+    version_changed = sidereon.load_antex(_antex(system="G"))
+    pcv_type_changed = sidereon.load_antex(
+        _antex(reference_type="OTHER ANT", reference_serial="SERIAL-2")
+    )
+    outer_comment_changed = sidereon.load_antex(_antex(outer_comment="changed outer"))
+    grid_changed = sidereon.load_antex(_antex(grid="     0.0  12.0   6.0"))
+    calibration_changed = sidereon.load_antex(_antex(calibration_date="02-JAN-20"))
+    frequency_changed = sidereon.load_antex(
+        _antex(pco="      1.50      2.00      3.00")
+    )
+    rms_changed = sidereon.load_antex(_antex(rms_pco="      0.11      0.20      0.30"))
+    sample_changed = sidereon.load_antex(
+        _antex(sample="   NOAZI    1.00    2.50    3.00")
+    )
+
+    _assert_eq_and_ne(parsed, repeated, header_changed)
+
+    antenna = parsed.antenna("TESTANT             SERIAL-1")
+    repeated_antenna = repeated.antenna("TESTANT             SERIAL-1")
+    changed_antenna = grid_changed.antenna("TESTANT             SERIAL-1")
+    assert antenna is not None and repeated_antenna is not None
+    assert changed_antenna is not None
+    _assert_eq_and_ne(antenna, repeated_antenna, changed_antenna)
+
+    _assert_eq_and_ne(parsed.header, repeated.header, header_changed.header)
+    _assert_eq_and_ne(
+        parsed.header.version,
+        repeated.header.version,
+        version_changed.header.version,
+    )
+    _assert_eq_and_ne(
+        parsed.header.pcv_type,
+        repeated.header.pcv_type,
+        pcv_type_changed.header.pcv_type,
+    )
+
+    _assert_eq_and_ne(
+        parsed.outer_comments[0],
+        repeated.outer_comments[0],
+        outer_comment_changed.outer_comments[0],
+    )
+    assert len(parsed.outer_comments) == 2
+
+    assert antenna.zenith_grid is not None
+    assert repeated_antenna.zenith_grid is not None
+    assert changed_antenna.zenith_grid is not None
+    _assert_eq_and_ne(
+        antenna.zenith_grid,
+        repeated_antenna.zenith_grid,
+        changed_antenna.zenith_grid,
+    )
+    _assert_eq_and_ne(
+        antenna.calibrations[0],
+        repeated_antenna.calibrations[0],
+        calibration_changed.antenna("TESTANT             SERIAL-1").calibrations[0],
+    )
+
+    frequency = antenna.frequency_sections[0]
+    repeated_frequency = repeated_antenna.frequency_sections[0]
+    _assert_eq_and_ne(
+        frequency,
+        repeated_frequency,
+        frequency_changed.antenna("TESTANT             SERIAL-1").frequency_sections[0],
+    )
+    assert frequency.rms is not None and repeated_frequency.rms is not None
+    changed_rms = (
+        rms_changed.antenna("TESTANT             SERIAL-1").frequency_sections[0].rms
+    )
+    assert changed_rms is not None
+    _assert_eq_and_ne(frequency.rms, repeated_frequency.rms, changed_rms)
+    _assert_eq_and_ne(
+        frequency.pcv_samples[1],
+        repeated_frequency.pcv_samples[1],
+        sample_changed.antenna("TESTANT             SERIAL-1")
+        .frequency_sections[0]
+        .pcv_samples[1],
+    )
+
+    _assert_eq_and_ne(
+        _invalid_pcv_type("X"),
+        _invalid_pcv_type("X"),
+        _invalid_pcv_type("Y"),
+    )