arkparser 0.4.2__tar.gz → 0.4.3__tar.gz

{arkparser-0.4.2 → arkparser-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparser
-Version: 0.4.2
+Version: 0.4.3
 Summary: Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files
 Author: Vertyco
 License-Expression: MIT

{arkparser-0.4.2 → arkparser-0.4.3}/arkparser/__init__.py

@@ -95,4 +95,4 @@ __all__ = [
     "ArkParseError",
 ]
 
-__version__ = "0.4.2"
+__version__ = "0.4.3"

{arkparser-0.4.2 → arkparser-0.4.3}/arkparser/common/binary_reader.py

@@ -242,9 +242,13 @@ class BinaryReader:
         if length == 0:
             return ""
         if length == 1:
+            if self._pos + 1 > self._size:
+                raise EndOfDataError(1, self._size - self._pos)
             self._pos += 1  # single null byte
             return ""
         if length == -1:
+            if self._pos + 2 > self._size:
+                raise EndOfDataError(2, self._size - self._pos)
             self._pos += 2  # UTF-16 null
             return ""
         if length < 0:

{arkparser-0.4.2 → arkparser-0.4.3}/arkparser/data_models.py

@@ -472,7 +472,9 @@ class CryopodCreature:
         Both ASA and ASE store cryopod creature data using:
         - CustomDataStrings: [class_name, display_name, colors_str, ?, gender, ?, ?, ...]
           - ASE has 7 strings, ASA has 10+ strings (with species at index 9)
-        - CustomDataFloats: [current_stats x 12, max_stats x 12, ...]
+        - CustomDataFloats: ASE = [current x 12, max x 12, +1] (25); ASA = [current
+          x 11 (no CraftingSkill), max x 11, extras] (36). See the per-format
+          branch below — the layouts genuinely differ in current-stat width.
         - CustomDataNames: Color names for the 6 color regions
 
         Args:

{arkparser-0.4.2 → arkparser-0.4.3}/arkparser/export.py

@@ -33,15 +33,20 @@ from __future__ import annotations
 
 import datetime as dt
 import json
+import logging
+import math
 import re
 import typing as t
 from pathlib import Path
 
+from arkparser.common.exceptions import ArkParseError
 from arkparser.common.map_config import MapConfig
 from arkparser.common.normalization import normalize_indexed_data, normalize_indexed_list
 from arkparser.data_models import CryopodCreature
 from arkparser.files import CloudInventory, Profile, Tribe
 
+logger = logging.getLogger(__name__)
+
 _CRYOPOD_CLASS_PATTERNS: tuple[str, ...] = (
     "Cryopod", "SoulTrap", "Vivarium", "DinoBall",
 )
@@ -122,9 +127,12 @@ def _float(val: t.Any, default: float = 0.0) -> float:
     if val is None or val is False:
         return default
     try:
-        return float(val)
+        result = float(val)
     except (TypeError, ValueError):
         return default
+    # inf/nan (corrupt or extreme bit patterns) are not valid JSON tokens and
+    # crash strict downstream parsers (JS JSON.parse, Pydantic). Coerce to default.
+    return result if math.isfinite(result) else default
 
 
 def _str(val: t.Any) -> str:
@@ -285,17 +293,19 @@ def _gps_payload(
     loc = getattr(obj, "location", None)
     if loc is None:
         return {"ccc": "0 0 0", "lat": 0.0, "lon": 0.0}
-    x = getattr(loc, "x", 0.0) or 0.0
-    y = getattr(loc, "y", 0.0) or 0.0
-    z = getattr(loc, "z", 0.0) or 0.0
+    # _float coerces non-finite (inf/nan) coords to 0.0 — those are invalid
+    # JSON tokens that crash strict downstream parsers.
+    x = _float(getattr(loc, "x", 0.0))
+    y = _float(getattr(loc, "y", 0.0))
+    z = _float(getattr(loc, "z", 0.0))
     if ndigits is not None:
         x = round(x, ndigits)
         y = round(y, ndigits)
         z = round(z, ndigits)
     out: dict[str, t.Any] = {"ccc": f"{x} {y} {z}"}
     if map_config is not None:
-        lat = float(map_config.ue_to_lat(y))
-        lon = float(map_config.ue_to_lon(x))
+        lat = _float(map_config.ue_to_lat(y))
+        lon = _float(map_config.ue_to_lon(x))
         if ndigits is not None:
             lat = round(lat, ndigits)
             lon = round(lon, ndigits)
@@ -331,9 +341,11 @@ def _approx_real_datetime(
         return None
     try:
         offset = float(in_game_time) - game_time
-    except (TypeError, ValueError):
+        return mtime + dt.timedelta(seconds=offset)
+    except (TypeError, ValueError, OverflowError, OSError):
+        # Mirror legacy GetApproxDateTimeOf's try/catch: a garbage/huge in-game
+        # time overflows datetime arithmetic — legacy returns null, so do we.
         return None
-    return mtime + dt.timedelta(seconds=offset)
 
 
 def _combine_dino_id(id1: t.Any, id2: t.Any) -> int:
@@ -672,7 +684,7 @@ def _is_meaningful_value(value: t.Any) -> bool:
         return False
     if isinstance(value, (list, dict, str)) and len(value) == 0:
         return False
-    if isinstance(value, float) and value != value:  # NaN
+    if isinstance(value, float) and not math.isfinite(value):  # NaN or +/-inf
         return False
     if isinstance(value, str) and value == "Unknown":
         return False
@@ -1033,6 +1045,7 @@ def _tamed_dict(
     lookup: dict[t.Any, t.Any],
     map_config: MapConfig | None,
     save: t.Any = None,
+    stored: bool = False,
 ) -> dict[str, t.Any]:
     base_pts = _stat_array(status, "NumberOfLevelUpPointsApplied")
     tamed_pts = _stat_array(status, "NumberOfLevelUpPointsAppliedTamed")
@@ -1040,6 +1053,22 @@ def _tamed_dict(
     base_level = _int(_prop(status, "BaseCharacterLevel"), default=1) or 1
     extra_level = _int(_prop(status, "ExtraCharacterLevel"))
     dino_id = _combine_dino_id(_prop(obj, "DinoID1"), _prop(obj, "DinoID2"))
+    # Legacy negates the id of stored (cryo/vivarium) creatures so they don't
+    # collide with live tames (ContentTamedCreature.cs:122-126/228-232). The
+    # dinoid field stays positive (C# sets DinoId = Id.ToString() before negating).
+    is_stored = (
+        stored
+        or bool(_prop(obj, "IsInCryo", default=False))
+        or bool(_prop(obj, "IsInVivarium", default=False))
+    )
+    display_id = -dino_id if (is_stored and dino_id != 0) else dino_id
+    # Legacy blanks the tamer once a creature is imprinted (ContentTamedCreature
+    # .cs:109-114/215-220): imprinted dinos report an imprinter, not a tamer.
+    imprinter_player_id = _int(_prop(obj, "ImprinterPlayerDataID"))
+    imprinter_name = _str(_prop(obj, "ImprinterName"))
+    tamer = _str(_prop(obj, "TamerString"))
+    if imprinter_player_id > 0 or imprinter_name:
+        tamer = ""
     colors = _colors(obj)
     is_female = bool(_prop(obj, "bIsFemale", default=False))
     targeting_team = _int(_prop(obj, "TargetingTeam"))
@@ -1054,11 +1083,11 @@ def _tamed_dict(
     _, cuddle_iso = _iso_pair(obj, "BabyNextCuddleTime", save)
 
     data: dict[str, t.Any] = {
-        "id": dino_id,
+        "id": display_id,
         "tribeid": targeting_team,
         "tribe": tribe_name or None,
-        "tamer": _str(_prop(obj, "TamerString")),
-        "imprinter": _str(_prop(obj, "ImprinterName")),
+        "tamer": tamer,
+        "imprinter": imprinter_name,
         "imprint": _float(_prop(status, "DinoImprintingQuality")),
         "creature": getattr(obj, "class_name", "") or "",
         "name": _str(_prop(obj, "TamedName")),
@@ -1104,7 +1133,7 @@ def _tamed_dict(
             else None
         ),
         "current_stats": _current_stats_dict(status),
-        "imprinter_player_id": _int(_prop(obj, "ImprinterPlayerDataID")),
+        "imprinter_player_id": imprinter_player_id,
         "imprinter_net_id": _str(_prop(obj, "ImprinterPlayerUniqueNetId")),
         "taming_team_id": _int(_prop(obj, "TamingTeamID")),
         "owning_player_id": _int(_prop(obj, "OwningPlayerID")),
@@ -1251,7 +1280,7 @@ def _export_world_cryopods(
             for key, val in owner_info.items():
                 if val and not cryo.creature_props.get(key):
                     cryo.creature_props[key] = val
-        record = _tamed_dict(actor, status, empty_lookup, map_config, save)
+        record = _tamed_dict(actor, status, empty_lookup, map_config, save, stored=True)
         # The synthetic actor carries no IsInCryo property; force the legacy
         # flag so consumers can distinguish in-world tames from stored ones.
         record["cryo"] = True
@@ -1312,11 +1341,29 @@ def _cryo_tamed_record(
     cryo: CryopodCreature,
     map_config: MapConfig | None,
     empty_lookup: dict[t.Any, t.Any],
+    upload_time: int = 0,
 ) -> dict[str, t.Any]:
-    """Decode one cryopod blob into a tamed record flagged ``cryo=True``."""
+    """Decode one cryopod blob into a tamed record flagged ``cryo=True``.
+
+    ``upload_time`` (unix seconds; cluster uploads only) populates
+    ``uploadedTime`` to match legacy (ContentContainer.cs:387-389); 0 omits it.
+    """
     actor, status = _cryo_props_to_synthetic(cryo)
+    # Cluster-UPLOADED creatures are not cryo/vivarium in legacy terms (their
+    # IsInCryo is false), so legacy keeps their id positive — do NOT negate.
+    # Only genuine in-world cryopod/vivarium creatures negate, via
+    # _export_world_cryopods passing stored=True directly to _tamed_dict.
     record = _tamed_dict(actor, status, empty_lookup, map_config)
     record["cryo"] = True
+    ut = _int(upload_time)
+    if ut:
+        # uploadedTime doubles as the downstream "is uploaded" discriminator.
+        try:
+            record["uploadedTime"] = dt.datetime.fromtimestamp(
+                ut, tz=dt.timezone.utc
+            ).isoformat()
+        except (OverflowError, OSError, ValueError):
+            pass
     return record
 
 
@@ -1391,7 +1438,11 @@ def export_cluster_uploads(
             cryo = CryopodCreature.from_cryopod_bytes(byte_arr)
             if cryo is None:
                 continue
-            _append_unique_tame(out, seen_ids, _cryo_tamed_record(cryo, map_config, empty_lookup))
+            upload_time = _int(entry.get("UploadTime"))
+            _append_unique_tame(
+                out, seen_ids,
+                _cryo_tamed_record(cryo, map_config, empty_lookup, upload_time),
+            )
         # Cryopods uploaded as items (rare but present, especially in ASA
         # tribute transfers) embed a CryopodCreature in CustomItemDatas.
         for item in inv.uploaded_items:
@@ -1400,11 +1451,14 @@ def export_cluster_uploads(
             cryo = item.cryopod_creature
             if cryo is None:
                 continue
-            _append_unique_tame(out, seen_ids, _cryo_tamed_record(cryo, map_config, empty_lookup))
+            _append_unique_tame(
+                out, seen_ids,
+                _cryo_tamed_record(cryo, map_config, empty_lookup, _int(item.upload_time)),
+            )
     return out
 
 
-def _uploaded_item_dict(item: t.Any) -> dict[str, t.Any]:
+def _uploaded_item_dict(item: t.Any, save: t.Any = None) -> dict[str, t.Any]:
     """Shape a single ``UploadedItem`` as an inventory-style entry.
 
     Mirrors ``_inventory_items``: ``itemId``/``qty``/``blueprint`` at top,
@@ -1451,16 +1505,28 @@ def _uploaded_item_dict(item: t.Any) -> dict[str, t.Any]:
             snake = _pascal_to_snake(name)
             pre[snake] = _normalize_stat_value(snake, value)
         entry.update(_apply_stat_aliases(pre, item_class=class_name))
-    upload_time = item.upload_time
-    if upload_time:
-        # Key name matches the legacy ASV item schema (uploadedTime), which
-        # downstream consumers use as the "is uploaded" discriminator.
+    # Legacy derives item uploadedTime from the inner ArkTributeItem CreationTime
+    # via the in-game anchor file_mtime + (t - game_time) (ContentItem.cs:52 +
+    # ContentContainer.cs:301-303). ASA cluster items instead carry a real unix
+    # epoch in the outer UploadTime (CreationTime is 0), so fall back to that.
+    # Always emit an ISO string (never a raw int) so the field type is stable.
+    iso: str | None = None
+    creation_time = (
+        _float(ark_tribute.get("CreationTime")) if isinstance(ark_tribute, dict) else 0.0
+    )
+    if creation_time and save is not None:
+        anchored = _approx_real_datetime(creation_time, save)
+        if anchored is not None:
+            iso = anchored.isoformat()
+    if iso is None and item.upload_time:
         try:
-            entry["uploadedTime"] = dt.datetime.fromtimestamp(
-                float(upload_time), tz=dt.timezone.utc
+            iso = dt.datetime.fromtimestamp(
+                float(item.upload_time), tz=dt.timezone.utc
             ).isoformat()
         except (OverflowError, OSError, ValueError, TypeError):
-            entry["uploadedTime"] = upload_time
+            iso = None
+    if iso is not None:
+        entry["uploadedTime"] = iso
     return entry
 
 
@@ -1486,6 +1552,7 @@ def _is_placeholder_item(item: t.Any) -> bool:
 
 def export_cluster_items(
     cluster_inventories: t.Iterable[CloudInventory],
+    save: t.Any = None,
 ) -> list[dict[str, t.Any]]:
     """Export every uploaded item across the supplied cloud inventories.
 
@@ -1501,7 +1568,7 @@ def export_cluster_items(
         for item in inv.uploaded_items:
             if _is_placeholder_item(item):
                 continue
-            out.append(_uploaded_item_dict(item))
+            out.append(_uploaded_item_dict(item, save))
     return out
 
 
@@ -1726,6 +1793,7 @@ def _player_status_by_data_id(save: t.Any, lookup: dict[t.Any, t.Any]) -> dict[i
 
 def _cluster_items_by_xuid(
     cluster_inventories: t.Iterable[CloudInventory],
+    save: t.Any = None,
 ) -> dict[str, list[dict[str, t.Any]]]:
     """Group uploaded items by cloud-file stem (= player's unique_id / xuid).
 
@@ -1747,7 +1815,7 @@ def _cluster_items_by_xuid(
         for item in inv.uploaded_items:
             if _is_placeholder_item(item):
                 continue
-            entry = _uploaded_item_dict(item)
+            entry = _uploaded_item_dict(item, save)
             entry["uploaded"] = True
             bucket.append(entry)
     return out
@@ -1762,7 +1830,7 @@ def export_players(
     lookup = _save_lookup(save)
     pawn_status_by_id = _player_status_by_data_id(save, lookup)
     cluster_items = (
-        _cluster_items_by_xuid(cluster_inventories) if cluster_inventories else {}
+        _cluster_items_by_xuid(cluster_inventories, save) if cluster_inventories else {}
     )
     results: list[dict[str, t.Any]] = []
     for entry in profiles:
@@ -2303,7 +2371,11 @@ def _load_cluster_inventories(
                 continue
             try:
                 loaded.append(CloudInventory.load(entry))
-            except (OSError, ValueError, Exception):  # noqa: BLE001
+            except (OSError, ArkParseError) as e:
+                # Skip unreadable/corrupt cluster files but record which one —
+                # a silent drop hides every upload in that file and looks like
+                # the player simply has no uploads. Unexpected errors propagate.
+                logger.warning("Skipping cluster file %s: %s", entry, e)
                 continue
         return loaded
     return [inv for inv in cluster if isinstance(inv, CloudInventory)]

{arkparser-0.4.2 → arkparser-0.4.3}/arkparser/files/world_save.py

@@ -642,14 +642,24 @@ class WorldSave:
         save.is_asa = True
         save._parse_errors = []
 
+        conn = None
         try:
             conn = sqlite3.connect(str(path))
             save._read_asa_header(conn)
-            save._read_asa_actor_locations(conn)
+            # Actor locations are positional enrichment, not load-critical. A
+            # malformed/padded ActorTransforms blob must not abort the whole
+            # save — record it and continue with object data only. (EndOfDataError
+            # subclasses ArkParseError, so this catches both.)
+            try:
+                save._read_asa_actor_locations(conn)
+            except ArkParseError as e:
+                save._parse_errors.append(f"ActorTransforms: {e}")
             save._read_asa_game_objects(conn, load_properties, max_objects)
-            conn.close()
         except sqlite3.Error as e:
             raise ArkParseError(f"SQLite error reading ASA world save: {e}")
+        finally:
+            if conn is not None:
+                conn.close()
 
         save.container = GameObjectContainer(objects=save.objects)
         save.container.build_relationships()
@@ -721,7 +731,10 @@ class WorldSave:
         reader = BinaryReader.from_bytes(row[0])
         self.actor_locations = {}
 
-        while reader.remaining >= 16:
+        # Each record is exactly 72 bytes: 16 (GUID) + 6*8 (xyz + pitch/yaw/roll)
+        # + 8 (pad). Guard on the full record size so a non-72-aligned tail can't
+        # underflow mid-record and raise instead of stopping cleanly.
+        while reader.remaining >= 72:
             guid_bytes = reader.read_bytes(16)
             if all(b == 0 for b in guid_bytes):
                 break

{arkparser-0.4.2 → arkparser-0.4.3}/arkparser/game_objects/game_object.py

@@ -12,6 +12,7 @@ import typing as t
 from collections import defaultdict
 from dataclasses import dataclass, field
 
+from ..common.exceptions import CorruptDataError
 from ..properties.registry import read_properties, read_property
 from .location import LocationData
 
@@ -19,6 +20,11 @@ if t.TYPE_CHECKING:
     from ..common.binary_reader import BinaryReader
     from ..properties.base import Property
 
+# Upper sanity bound for the ASE object-table count. Legitimate maps top out
+# in the low millions; a misaligned header decodes a garbage count (commonly a
+# negative int32 read as a ~4-billion uint), so anything past this is corruption.
+MAX_OBJECT_COUNT = 100_000_000
+
 
 @dataclass(slots=True)
 class GameObject:
@@ -69,6 +75,11 @@ class GameObject:
             if bucket is None:
                 idx[prop.name] = {prop.index: prop}
             else:
+                # First-writer wins, matching legacy C# GetPropertyValue
+                # (IPropertyContainer.cs:45) which returns the first (name,
+                # index) match. _serialize_properties keeps all occurrences in
+                # the additive `properties` dict; lookups intentionally mirror
+                # legacy here. Do not switch to last-wins.
                 bucket.setdefault(prop.index, prop)
         self._prop_index = idx
         return idx
@@ -163,7 +174,12 @@ class GameObject:
                 return True
             return False
         if prop.type_name == "ArrayProperty" and getattr(prop, "array_type", "") == "ObjectProperty":
-            return all(isinstance(v, (tuple, list)) and len(v) == 2 and v[0] == "id" for v in prop.value)
+            # all() over an empty list is True; require a non-empty value so an
+            # empty object-ref array is serialized rather than silently dropped.
+            return bool(prop.value) and all(
+                isinstance(v, (tuple, list)) and len(v) == 2 and v[0] == "id"
+                for v in prop.value
+            )
         return False
 
     @staticmethod
@@ -374,7 +390,12 @@ def read_object_list(
     Returns:
         List of GameObject instances with headers populated.
     """
-    count = reader.read_int32()
+    count = reader.read_uint32()
+    if count > MAX_OBJECT_COUNT:
+        raise CorruptDataError(
+            f"object count {count} exceeds maximum {MAX_OBJECT_COUNT} "
+            "(likely a misaligned object table header)"
+        )
     objects: list[GameObject] = []
 
     for i in range(count):

{arkparser-0.4.2 → arkparser-0.4.3}/arkparser/properties/compound.py

@@ -13,6 +13,7 @@ import typing as t
 import uuid
 from dataclasses import dataclass, field
 
+from ..common.exceptions import UnknownPropertyError
 from ..structs import registry as struct_registry
 from .base import Property, PropertyHeader, read_name
 
@@ -552,9 +553,12 @@ def _read_array_elements(
                 else:
                     values.append(struct)
     else:
-        # Unknown array type - read as raw bytes
-        # We can't determine element size, so just note it
-        values.append(f"<UnknownArray({array_type}): {count} elements>")
+        # Unknown element type: element sizes are indeterminate, so reading on
+        # would desync the stream and corrupt every later property in this
+        # object. Raise instead of emitting a placeholder — callers parse each
+        # object in isolation (per-blob in ASA, per-offset in ASE) and record
+        # the failure, so the damage stays contained to this one object.
+        raise UnknownPropertyError(f"ArrayProperty element type {array_type!r}")
 
     return values
 
@@ -665,8 +669,11 @@ def _read_worldsave_array_elements(
             _padding = reader.read_int32()
             values.append(ref_name)
     else:
-        # Unknown type
-        values.append(f"<UnknownWorldSaveArray({element_type}): {count} elements>")
+        # Unknown element type: bail rather than desync the object stream (see
+        # _read_array_elements). The per-object parse guard contains the failure.
+        raise UnknownPropertyError(
+            f"WorldSave ArrayProperty element type {element_type!r}"
+        )
 
     return values
 

{arkparser-0.4.2 → arkparser-0.4.3}/arkparser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparser
-Version: 0.4.2
+Version: 0.4.3
 Summary: Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files
 Author: Vertyco
 License-Expression: MIT

{arkparser-0.4.2 → arkparser-0.4.3}/arkparser.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ tests/test_data_models.py
 tests/test_export.py
 tests/test_game_objects.py
 tests/test_profile.py
+tests/test_review_fixes.py
 tests/test_tribe.py
 tests/test_v13_property_layouts.py
 tests/test_version_detection.py

{arkparser-0.4.2 → arkparser-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "arkparser"
-version = "0.4.2"
+version = "0.4.3"
 description = "Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files"
 readme = "README.md"
 license = "MIT"

arkparser-0.4.3/tests/test_review_fixes.py

@@ -0,0 +1,138 @@
+"""Regression tests for the code-review fix batch (fixture-free, pure logic).
+
+Each test pins a specific reviewed defect so it cannot silently regress:
+  #1  tamer blanked when a creature is imprinted
+  #2  inf/nan floats never reach JSON (strict-parser safe)
+  #5  in-world cryo/vivarium id negated; dinoid stays positive
+  #13 read_string bounds-checks the length==1 / length==-1 fast paths
+  #15 read_object_list rejects an absurd (corrupt-header) object count
+"""
+
+import json
+import types
+
+import pytest
+
+from arkparser.common.binary_reader import BinaryReader
+from arkparser.common.exceptions import CorruptDataError, EndOfDataError
+from arkparser.export import _SyntheticGameObject, _float, _gps_payload, _tamed_dict
+from arkparser.game_objects.game_object import MAX_OBJECT_COUNT, read_object_list
+
+
+def _status() -> _SyntheticGameObject:
+    return _SyntheticGameObject("DinoCharacterStatusComponent_BP_C", {})
+
+
+# --- #2: finite floats only -------------------------------------------------
+
+def test_float_coerces_non_finite_to_default() -> None:
+    assert _float(float("inf")) == 0.0
+    assert _float(float("-inf")) == 0.0
+    assert _float(float("nan")) == 0.0
+    assert _float(float("inf"), default=1.5) == 1.5
+    # finite values pass through unchanged
+    assert _float(3.25) == 3.25
+    assert _float(0.0) == 0.0
+
+
+def test_gps_payload_is_strict_json_safe() -> None:
+    loc = types.SimpleNamespace(x=float("inf"), y=float("nan"), z=-float("inf"))
+    # _gps_payload only reads ``obj.location``; a namespace stand-in is enough.
+    obj = types.SimpleNamespace(location=loc)
+    payload = _gps_payload(obj, None)
+    # No NaN/Infinity tokens survive — strict parsers (JS, Pydantic) reject them.
+    text = json.dumps(payload)
+    assert "Infinity" not in text and "NaN" not in text
+    json.loads(text, parse_constant=lambda tok: pytest.fail(f"non-finite: {tok}"))
+    assert payload["ccc"] == "0.0 0.0 0.0"
+
+
+# --- #1: tamer blanked on imprint ------------------------------------------
+
+def test_tamed_dict_blanks_tamer_when_imprinted_by_player_id() -> None:
+    actor = _SyntheticGameObject(
+        "Dodo_C", {"TamerString": "Bob", "ImprinterPlayerDataID": 42}
+    )
+    rec = _tamed_dict(actor, _status(), {}, None)
+    assert rec["tamer"] == ""
+    assert rec["imprinter_player_id"] == 42
+
+
+def test_tamed_dict_blanks_tamer_when_imprinter_name_present() -> None:
+    actor = _SyntheticGameObject(
+        "Dodo_C", {"TamerString": "Bob", "ImprinterName": "Alice"}
+    )
+    rec = _tamed_dict(actor, _status(), {}, None)
+    assert rec["tamer"] == ""
+    assert rec["imprinter"] == "Alice"
+
+
+def test_tamed_dict_keeps_tamer_when_not_imprinted() -> None:
+    actor = _SyntheticGameObject("Dodo_C", {"TamerString": "Bob"})
+    rec = _tamed_dict(actor, _status(), {}, None)
+    assert rec["tamer"] == "Bob"
+
+
+# --- #5: cryo/vivarium id negation (dinoid stays positive) ------------------
+
+def test_tamed_dict_negates_id_when_stored() -> None:
+    actor = _SyntheticGameObject("Dodo_C", {"DinoID1": 100, "DinoID2": 200})
+    live = _tamed_dict(actor, _status(), {}, None, stored=False)
+    stored = _tamed_dict(actor, _status(), {}, None, stored=True)
+    assert live["id"] > 0
+    assert stored["id"] == -live["id"]
+    # dinoid is the stable positive identity in BOTH cases (legacy parity).
+    assert stored["dinoid"] == live["dinoid"]
+    assert not stored["dinoid"].startswith("-")
+
+
+def test_tamed_dict_negates_id_via_is_in_cryo_prop() -> None:
+    actor = _SyntheticGameObject(
+        "Dodo_C", {"DinoID1": 1, "DinoID2": 2, "IsInCryo": True}
+    )
+    rec = _tamed_dict(actor, _status(), {}, None)
+    assert rec["id"] < 0
+    assert not rec["dinoid"].startswith("-")
+
+
+def test_tamed_dict_zero_id_not_negated() -> None:
+    actor = _SyntheticGameObject("Dodo_C", {"DinoID1": 0, "DinoID2": 0})
+    rec = _tamed_dict(actor, _status(), {}, None, stored=True)
+    assert rec["id"] == 0
+
+
+# --- #13: read_string fast-path bounds checks -------------------------------
+
+def test_read_string_len1_truncated_raises() -> None:
+    # length prefix == 1 (single null byte) but no byte follows it.
+    reader = BinaryReader.from_bytes((1).to_bytes(4, "little"))
+    with pytest.raises(EndOfDataError):
+        reader.read_string()
+
+
+def test_read_string_utf16_null_truncated_raises() -> None:
+    # length prefix == -1 (UTF-16 null, needs 2 bytes) but none follow.
+    reader = BinaryReader.from_bytes((-1).to_bytes(4, "little", signed=True))
+    with pytest.raises(EndOfDataError):
+        reader.read_string()
+
+
+def test_read_string_len1_valid_roundtrips() -> None:
+    # Happy path still works: prefix 1 + the null byte present -> "".
+    reader = BinaryReader.from_bytes((1).to_bytes(4, "little") + b"\x00")
+    assert reader.read_string() == ""
+
+
+# --- #15: object-count sanity bound -----------------------------------------
+
+def test_read_object_list_rejects_absurd_count() -> None:
+    # 0xFFFFFFFF as uint32 is far above MAX_OBJECT_COUNT (a misaligned header).
+    reader = BinaryReader.from_bytes(b"\xff\xff\xff\xff")
+    with pytest.raises(CorruptDataError):
+        read_object_list(reader, is_asa=False)
+
+
+def test_read_object_list_zero_count_ok() -> None:
+    reader = BinaryReader.from_bytes((0).to_bytes(4, "little"))
+    assert read_object_list(reader, is_asa=False) == []
+    assert MAX_OBJECT_COUNT > 1_000_000