@@ -1,7 +1,9 @@
 """SQLite reference SQL profile for the strict OpenStatSpec wide-table contract."""
 
 import json
+import math
 import re
+import sys
 from datetime import UTC, datetime
 from uuid import uuid4
 from collections.abc import Iterable, Mapping
@@ -198,6 +200,18 @@ def missing_rule_catalog(metadata: MetaData) -> Table:
 
 
 def _typed_endpoint(value: Any) -> tuple[str, float | None, str | None]:
+    """Encode typed values without losing SPSS LOWEST/HIGHEST sentinels.
+
+    ReadStat exposes a LOWEST range bound as NaN and HIGHEST as positive
+    infinity. Storing either in a SQL binary64 column is not portable, so the
+    catalog records an explicit endpoint type and reconstructs the ReadStat
+    writer input on export.
+    """
+    if isinstance(value, float):
+        if math.isnan(value):
+            return "lowest", None, None
+        if math.isinf(value):
+            return ("highest" if value > 0 else "lowest"), None, None
     if isinstance(value, bool):
         return "text", None, str(value)
     if isinstance(value, (int, float)):
@@ -382,7 +396,12 @@ def create_wide_dataset(
 
 
 def _endpoint_from_row(row: Mapping[str, Any], *, prefix: str) -> Any:
-    return row[f"{prefix}_numeric"] if row[f"{prefix}_type"] == "numeric" else row[f"{prefix}_text"]
+    endpoint_type = row[f"{prefix}_type"]
+    if endpoint_type == "lowest":
+        return -sys.float_info.max
+    if endpoint_type == "highest":
+        return sys.float_info.max
+    return row[f"{prefix}_numeric"] if endpoint_type == "numeric" else row[f"{prefix}_text"]
 
 
 def read_wide_dataset(*, database_url: str, dataset_id: str) -> tuple[dict[str, Any], list[dict[str, Any]], list[dict[str, Any]]]:
 
@@ -1,10 +1,119 @@
-"""Semantic comparison helpers for supported SAV/ZSAV round trips."""
+"""Reusable fixtures and semantic comparators for supported SAV/ZSAV round trips.
 
+These helpers deliberately compare only metadata that the Python adapter and
+its current SAV writer expose. Attributes, variable sets, and
+multiple-response sets are not asserted here because they are explicitly
+reported as unsupported fidelity losses.
+"""
+
+import math
+import sys
 from pathlib import Path
 from typing import Any
 
 import pandas as pd
 import pyreadstat
+from pandas.testing import assert_frame_equal
+
+
+def write_supported_semantics_fixture(destination: str | Path) -> dict[str, Any]:
+    """Write a fixture spanning every currently supported dictionary semantic.
+
+    -sys.float_info.max and sys.float_info.max are how ReadStat represents
+    SPSS LOWEST and HIGHEST missing-range endpoints on write. ReadStat exposes
+    them as NaN and +inf when the SAV/ZSAV file is read back; the comparator
+    canonicalizes those markers.
+    """
+    destination = Path(destination)
+    long_text = "Õ🙂漢字" * 90
+    frame = pd.DataFrame({
+        "lowest_range": [-2.0, -1.0, 0.0, 7.0],
+        "highest_range": [-99.0, 0.0, 1.0, 42.0],
+        "code": [3.0, 1.0, 2.0, 1.0],
+        "status": ["NA", "DK", "ok", ""],
+        "comment": [long_text, "", "näide", long_text],
+        "interview_date": [23123.0, 23124.0, 23125.0, 23126.0],
+    })
+    pyreadstat.write_sav(
+        frame,
+        destination,
+        compress=destination.suffix.lower() == ".zsav",
+        file_label="OpenStatSpec supported-semantics fixture",
+        column_labels={
+            "lowest_range": "LOWEST-style missing range",
+            "highest_range": "HIGHEST-style missing range",
+            "code": "Ordered numeric code",
+            "status": "String missing code",
+            "comment": "Long UTF-8 comment",
+            "interview_date": "SPSS numeric date",
+        },
+        variable_value_labels={
+            # Deliberately non-sorted insertion order is part of the fixture.
+            "code": {3.0: "third", 1.0: "first", 2.0: "second"},
+            "status": {"DK": "don't know", "NA": "not answered", "ok": "valid"},
+        },
+        missing_ranges={
+            "lowest_range": [{"lo": -sys.float_info.max, "hi": -1.0}, 7.0],
+            "highest_range": [{"lo": 1.0, "hi": sys.float_info.max}, -99.0],
+            "status": ["NA", "DK"],
+        },
+        variable_measure={
+            "lowest_range": "scale",
+            "highest_range": "scale",
+            "code": "ordinal",
+            "status": "nominal",
+            "comment": "nominal",
+            "interview_date": "scale",
+        },
+        variable_display_width={
+            "lowest_range": 12,
+            "highest_range": 12,
+            "code": 8,
+            "status": 12,
+            "comment": 48,
+            "interview_date": 11,
+        },
+        variable_format={
+            "lowest_range": "F12.1",
+            "highest_range": "F12.1",
+            "code": "F8.0",
+            "status": "A8",
+            "comment": "A1024",
+            "interview_date": "DATE11",
+        },
+        note=["First ordered document", "Teine dokument: Õ🙂"],
+    )
+    return {"long_text": long_text}
+
+
+def _canonical_missing_endpoint(value: Any, *, endpoint: str) -> Any:
+    """Normalize ReadStat's public sentinels for SPSS LOWEST/HIGHEST."""
+    if isinstance(value, float):
+        if math.isnan(value):
+            return "<LOWEST>" if endpoint == "lo" else "<SYSTEM-NAN>"
+        if math.isinf(value):
+            return "<HIGHEST>" if value > 0 else "<LOWEST>"
+    return value
+
+
+def _canonical_missing_ranges(metadata: Any) -> dict[str, tuple[tuple[Any, Any], ...]]:
+    result: dict[str, tuple[tuple[Any, Any], ...]] = {}
+    for variable, rules in (getattr(metadata, "missing_ranges", {}) or {}).items():
+        result[variable] = tuple(
+            (
+                _canonical_missing_endpoint(rule.get("lo"), endpoint="lo"),
+                _canonical_missing_endpoint(rule.get("hi"), endpoint="hi"),
+            )
+            for rule in rules
+        )
+    return result
+
+
+def _ordered_value_labels(metadata: Any) -> dict[str, tuple[tuple[Any, str], ...]]:
+    return {
+        variable: tuple((value, str(label)) for value, label in labels.items())
+        for variable, labels in (getattr(metadata, "variable_value_labels", {}) or {}).items()
+    }
 
 
 def compare_sav_semantics(source: str | Path, exported: str | Path) -> dict[str, Any]:
@@ -13,11 +122,24 @@ def compare_sav_semantics(source: str | Path, exported: str | Path) -> dict[str,
     failures: list[str] = []
     if list(source_frame.columns) != list(exported_frame.columns):
         failures.append("variable-order")
-    if not source_frame.equals(exported_frame):
+    try:
+        assert_frame_equal(source_frame, exported_frame, check_dtype=True, check_like=False)
+    except AssertionError:
         failures.append("values-or-case-order")
-    for attribute in ("column_labels", "original_variable_types", "variable_measure", "missing_ranges", "notes", "file_label"):
+    for attribute in (
+        "column_labels",
+        "original_variable_types",
+        "variable_measure",
+        "variable_display_width",
+        "variable_storage_width",
+        "notes",
+        "file_label",
+        "file_encoding",
+    ):
         if getattr(source_meta, attribute, None) != getattr(exported_meta, attribute, None):
             failures.append(attribute)
-    if getattr(source_meta, "variable_value_labels", {}) != getattr(exported_meta, "variable_value_labels", {}):
+    if _canonical_missing_ranges(source_meta) != _canonical_missing_ranges(exported_meta):
+        failures.append("missing_ranges")
+    if _ordered_value_labels(source_meta) != _ordered_value_labels(exported_meta):
         failures.append("variable_value_labels")
-    return {"equivalent": not failures, "differences": failures}
+    return {"equivalent": not failures, "differences": failures}
@@ -1,7 +1,7 @@
 import hashlib
 import pytest
 import json
-from conformance import compare_sav_semantics
+from conformance import compare_sav_semantics, write_supported_semantics_fixture
 import sqlite3
 
 import openstatspec
@@ -192,3 +192,47 @@ def test_legacy_json_metadata_remains_exportable_after_catalog_migration(tmp_pat
     assert metadata.notes == ["legacy document"]
     assert metadata.variable_value_labels == {"code": {1.0: "one"}}
     assert metadata.missing_ranges == {"code": [{"lo": 2.0, "hi": 2.0}]}
+
+
+@pytest.mark.parametrize("suffix", [".sav", ".zsav"])
+def test_supported_spss_semantics_fixture_round_trips_through_sqlite(tmp_path, suffix: str) -> None:
+    # Attributes, variable sets, and MR sets are explicit fidelity losses, not
+    # currently supported round-trip semantics.
+    source = tmp_path / f"supported{suffix}"
+    database_path = tmp_path / f"supported-{suffix[1:]}.sqlite"
+    destination = tmp_path / f"supported-roundtrip{suffix}"
+    expected = write_supported_semantics_fixture(source)
+    dataset_id = f"supported-{suffix[1:]}"
+
+    result = openstatspec.import_sav(
+        source, database_url=f"sqlite:///{database_path}", dataset_id=dataset_id,
+    )
+    assert result["case_count"] == 4
+    assert openstatspec.validate(
+        database_url=f"sqlite:///{database_path}", dataset_id=dataset_id
+    )["valid"] is True
+
+    connection = sqlite3.connect(database_path)
+    assert connection.execute("select source_format, source_encoding from dataset_catalog where dataset_id = ?", (dataset_id,)).fetchone() == (suffix[1:].upper(), "UTF-8")
+    data_table = "data_supported_sav" if suffix == ".sav" else "data_supported_zsav"
+    assert connection.execute(
+        f"select comment from {data_table} order by __case_ordinal"
+    ).fetchall()[0] == (expected["long_text"],)
+    # Typed normalized catalog values retain insertion order and string-vs-number identity.
+    assert connection.execute(
+        "select ordinal, numeric_value, text_value, label from value_label_catalog "
+        "where dataset_id = ? and variable_ordinal = 3 order by ordinal",
+        (dataset_id,),
+    ).fetchall() == [
+        (1, 3.0, None, "third"),
+        (2, 1.0, None, "first"),
+        (3, 2.0, None, "second"),
+    ]
+
+    openstatspec.export_sav(
+        database_url=f"sqlite:///{database_path}",
+        dataset_id=dataset_id,
+        destination=destination,
+        allow_loss=["unobservable-source-dictionary-features"],
+    )
+    assert compare_sav_semantics(source, destination) == {"equivalent": True, "differences": []}