arkparser 0.4.5__tar.gz → 0.4.6__tar.gz

{arkparser-0.4.5 → arkparser-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparser
-Version: 0.4.5
+Version: 0.4.6
 Summary: Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files
 Author: Vertyco
 License-Expression: MIT
@@ -212,14 +212,14 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `mut-f`, `mut-m` | legacy | **Ancestor-line totals.** `RandomMutationsFemale` and `RandomMutationsMale`, single integers counting the total number of mutations that occurred down the maternal and paternal ancestry lines respectively. These are *not* per-stat, they share the `-m` token with the per-stat mutation block below but mean a different thing. Kept under the legacy names for ASVExport parity. |
 | `cryo` | legacy | `True` for creatures embedded inside cryopod / soultrap / vivarium / dinoball items in the world save, `False` for actor-in-world tames. `export_tamed` walks `WorldSave.iter_cryopod_creatures()` and emits one ASV_Tamed record per embedded creature in addition to the actor-in-world tames; on busy PvE servers cryopodded tames are the majority of the roster (e.g. 10,277 of 11,054 on a live Ragnarok_WP). Cluster-uploaded tames also surface here (via `export_cluster_uploads`) with `cryo=True`. |
 | `ccc` | legacy | `"{x} {y} {z}"` from `LocationData` |
-| `dinoid` | legacy | string form of `id` |
+| `dinoid` | legacy | string form of the dino id. **ASA**: decimal of the combined 64-bit `id`. **ASE**: the two halves concatenated as signed-int32 decimals (`str(DinoID1) + str(DinoID2)`), matching `ASVExport`. |
 | `isMating` | legacy | `bEnableTamedMating` |
 | `isNeutered` | legacy | `bNeutered` |
 | `isClone` | legacy | `bIsClone` or `bIsCloneDino` |
 | `tamedServer` | legacy | `TamedOnServerName` |
 | `uploadedServer` | legacy | `UploadedFromServerName` |
-| `maturation` | legacy | `str(int(BabyAge * 100))` (string for legacy parity) |
-| `traits` | legacy | `CreatureTraits` (full list of mutation trait class names) |
+| `maturation` | legacy | `str(int(BabyAge * 100))` — integer maturation percent (a baby with no `BabyAge` is `0`, a newborn). Note: legacy emits the full float string (e.g. `"7.5131035"`); arkparser truncates to the integer percent. Semantically equal and the downstream consumer coerces to `int` either way. |
+| `traits` | legacy | `CreatureTraits` as a list of `{"trait": <class>}` objects (matches `ASVExport`'s shape, not a flat string list) |
 | `inventory` | legacy | items from `MyInventoryComponent.InventoryItems`. Each entry carries `itemId`, `qty`, `blueprint`, plus a full snake_case property dump flattened in at the top level (`id`, `rating`, `durability`, `quality`, `damage`, `armor`, `durability_max`, `hypo`, `hyper`, `clip_size`, `weight`, `crafter`, `crafter_tribe`, `skill_bonus`, `loaded_ammo`, `spoils_at`, `spoiled_at`, `c0`..`c5`, `egg_*`, etc). `item_stat_values` is unpacked into the universal 8-slot ARK map (slot 0 `gen_quality`, 1 `armor`, 2 `durability_max`, 3 `damage`, 4 `clip_size`, 5 `hypo`, 6 `weight`, 7 `hyperthermal_insulation`); raw uint16s scaled by the per-blueprint multiplier (which lives in the UE blueprint, not the save). Default / unset values are filtered (no `craft_queue=0`, `skin=-1`, `color_pre_skin=[0]*6`, NaN spoil timers, etc). When the item is a **cryopod / soultrap / vivarium / dinoball** with an embedded creature, the entry is enriched with `dino_id` (combined 64-bit id matching the corresponding `ASV_Tamed` record), `dino_creature` (species / class name), and `dino_name` (`TamedName` if set). Cryopods stored in containers (cryofridges, vaults, dedicated storage) get the same enrichment. |
 | `father_id`, `mother_id` | added | combined dino id from the first `DinoAncestors` entry (`null` when missing) |
 | `father_name`, `mother_name` | added | name strings from the first `DinoAncestors` entry |
@@ -256,7 +256,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 
 | Field | Origin | Source / formula |
 |---|---|---|
-| `id`, `dinoid` | legacy | `(DinoID1 << 32) \| DinoID2` and its string form |
+| `id`, `dinoid` | legacy | `id` = `(DinoID1 << 32) \| DinoID2`. `dinoid` = its string form on **ASA**, or `str(DinoID1) + str(DinoID2)` (signed int32) on **ASE**, matching `ASVExport`. |
 | `creature` | legacy | `GameObject.class_name` |
 | `sex` | legacy | `"Female"` if `bIsFemale` else `"Male"` |
 | `lvl` | legacy | `BaseCharacterLevel` (status) |

{arkparser-0.4.5 → arkparser-0.4.6}/README.md

@@ -178,14 +178,14 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `mut-f`, `mut-m` | legacy | **Ancestor-line totals.** `RandomMutationsFemale` and `RandomMutationsMale`, single integers counting the total number of mutations that occurred down the maternal and paternal ancestry lines respectively. These are *not* per-stat, they share the `-m` token with the per-stat mutation block below but mean a different thing. Kept under the legacy names for ASVExport parity. |
 | `cryo` | legacy | `True` for creatures embedded inside cryopod / soultrap / vivarium / dinoball items in the world save, `False` for actor-in-world tames. `export_tamed` walks `WorldSave.iter_cryopod_creatures()` and emits one ASV_Tamed record per embedded creature in addition to the actor-in-world tames; on busy PvE servers cryopodded tames are the majority of the roster (e.g. 10,277 of 11,054 on a live Ragnarok_WP). Cluster-uploaded tames also surface here (via `export_cluster_uploads`) with `cryo=True`. |
 | `ccc` | legacy | `"{x} {y} {z}"` from `LocationData` |
-| `dinoid` | legacy | string form of `id` |
+| `dinoid` | legacy | string form of the dino id. **ASA**: decimal of the combined 64-bit `id`. **ASE**: the two halves concatenated as signed-int32 decimals (`str(DinoID1) + str(DinoID2)`), matching `ASVExport`. |
 | `isMating` | legacy | `bEnableTamedMating` |
 | `isNeutered` | legacy | `bNeutered` |
 | `isClone` | legacy | `bIsClone` or `bIsCloneDino` |
 | `tamedServer` | legacy | `TamedOnServerName` |
 | `uploadedServer` | legacy | `UploadedFromServerName` |
-| `maturation` | legacy | `str(int(BabyAge * 100))` (string for legacy parity) |
-| `traits` | legacy | `CreatureTraits` (full list of mutation trait class names) |
+| `maturation` | legacy | `str(int(BabyAge * 100))` — integer maturation percent (a baby with no `BabyAge` is `0`, a newborn). Note: legacy emits the full float string (e.g. `"7.5131035"`); arkparser truncates to the integer percent. Semantically equal and the downstream consumer coerces to `int` either way. |
+| `traits` | legacy | `CreatureTraits` as a list of `{"trait": <class>}` objects (matches `ASVExport`'s shape, not a flat string list) |
 | `inventory` | legacy | items from `MyInventoryComponent.InventoryItems`. Each entry carries `itemId`, `qty`, `blueprint`, plus a full snake_case property dump flattened in at the top level (`id`, `rating`, `durability`, `quality`, `damage`, `armor`, `durability_max`, `hypo`, `hyper`, `clip_size`, `weight`, `crafter`, `crafter_tribe`, `skill_bonus`, `loaded_ammo`, `spoils_at`, `spoiled_at`, `c0`..`c5`, `egg_*`, etc). `item_stat_values` is unpacked into the universal 8-slot ARK map (slot 0 `gen_quality`, 1 `armor`, 2 `durability_max`, 3 `damage`, 4 `clip_size`, 5 `hypo`, 6 `weight`, 7 `hyperthermal_insulation`); raw uint16s scaled by the per-blueprint multiplier (which lives in the UE blueprint, not the save). Default / unset values are filtered (no `craft_queue=0`, `skin=-1`, `color_pre_skin=[0]*6`, NaN spoil timers, etc). When the item is a **cryopod / soultrap / vivarium / dinoball** with an embedded creature, the entry is enriched with `dino_id` (combined 64-bit id matching the corresponding `ASV_Tamed` record), `dino_creature` (species / class name), and `dino_name` (`TamedName` if set). Cryopods stored in containers (cryofridges, vaults, dedicated storage) get the same enrichment. |
 | `father_id`, `mother_id` | added | combined dino id from the first `DinoAncestors` entry (`null` when missing) |
 | `father_name`, `mother_name` | added | name strings from the first `DinoAncestors` entry |
@@ -222,7 +222,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 
 | Field | Origin | Source / formula |
 |---|---|---|
-| `id`, `dinoid` | legacy | `(DinoID1 << 32) \| DinoID2` and its string form |
+| `id`, `dinoid` | legacy | `id` = `(DinoID1 << 32) \| DinoID2`. `dinoid` = its string form on **ASA**, or `str(DinoID1) + str(DinoID2)` (signed int32) on **ASE**, matching `ASVExport`. |
 | `creature` | legacy | `GameObject.class_name` |
 | `sex` | legacy | `"Female"` if `bIsFemale` else `"Male"` |
 | `lvl` | legacy | `BaseCharacterLevel` (status) |

{arkparser-0.4.5 → arkparser-0.4.6}/arkparser/__init__.py

@@ -95,4 +95,4 @@ __all__ = [
     "ArkParseError",
 ]
 
-__version__ = "0.4.5"
+__version__ = "0.4.6"

{arkparser-0.4.5 → arkparser-0.4.6}/arkparser/data_models.py

@@ -8,6 +8,7 @@ property data from ARK save files.
 from __future__ import annotations
 
 import logging
+import math
 import typing as t
 from dataclasses import dataclass, field
 
@@ -18,6 +19,21 @@ from .properties.registry import read_properties
 logger = logging.getLogger(__name__)
 
 
+def _finite(value: t.Any, default: float) -> float:
+    """Coerce to a finite float; NaN / inf / non-numeric collapse to ``default``.
+
+    Non-finite floats are invalid JSON tokens that crash strict serializers
+    (``json.dumps(allow_nan=False)``, JS ``JSON.parse``, pydantic). Legacy
+    ASVExport substitutes ``0.0001`` for a NaN item rating (ContentItem.cs:62);
+    other non-finite floats fall back to ``0.0``.
+    """
+    try:
+        result = float(value)
+    except (TypeError, ValueError):
+        return default
+    return result if math.isfinite(result) else default
+
+
 @dataclass
 class DinoStats:
     """Statistics for a creature."""
@@ -201,7 +217,7 @@ class UploadedCreature:
             dino_id1=data.get("DinoID1", 0),
             dino_id2=data.get("DinoID2", 0),
             level=level,
-            experience=data.get("DinoExperiencePoints", 0.0),
+            experience=_finite(data.get("DinoExperiencePoints", 0.0), 0.0),
             stats=stats,
             upload_time=data.get("UploadTime", 0),
             version=data.get("Version", 0.0),
@@ -735,8 +751,8 @@ class UploadedItem:
             item_id2=item_id.get("ItemID2", 0) if isinstance(item_id, dict) else 0,
             quantity=ark_tribute.get("ItemQuantity", 1) or 1,
             quality_index=ark_tribute.get("ItemQualityIndex", 0),
-            durability=ark_tribute.get("ItemDurability", 0.0),
-            rating=ark_tribute.get("ItemRating", 0.0),
+            durability=_finite(ark_tribute.get("ItemDurability", 0.0), 0.0),
+            rating=_finite(ark_tribute.get("ItemRating", 0.0), 0.0001),
             slot_index=ark_tribute.get("SlotIndex", 0),
             is_blueprint=ark_tribute.get("bIsBlueprint", False),
             is_engram=ark_tribute.get("bIsEngram", False),

{arkparser-0.4.5 → arkparser-0.4.6}/arkparser/export.py

@@ -355,6 +355,31 @@ def _combine_dino_id(id1: t.Any, id2: t.Any) -> int:
     return (a << 32) | (b & 0xFFFFFFFF)
 
 
+def _dino_id_str(id1: t.Any, id2: t.Any, is_asa: bool) -> str:
+    """Legacy ``dinoid`` string form (engine-dependent).
+
+    ASA emits the decimal of the combined 64-bit id (legacy
+    ``ContentCreature.cs:224`` ``DinoId = Id.ToString()``). ASE concatenates the
+    two id halves as *signed* int32 decimals (legacy ``ContentCreature.cs:378``
+    ``DinoID1.ToString() + DinoID2.ToString()``, where ``GetPropertyValue<int>``
+    reinterprets each stored uint32 as a signed int). The forms differ, so the
+    engine must be known; passing the wrong flag re-introduces the divergence.
+    """
+    assert isinstance(is_asa, bool), "is_asa must be bool"
+    a, b = _int(id1), _int(id2)
+    if a == 0 and b == 0:
+        return "0"
+    if is_asa:
+        return str((a << 32) | (b & 0xFFFFFFFF))
+    a32 = a & 0xFFFFFFFF
+    b32 = b & 0xFFFFFFFF
+    a32 = a32 - 0x100000000 if a32 & 0x80000000 else a32
+    b32 = b32 - 0x100000000 if b32 & 0x80000000 else b32
+    result = f"{a32}{b32}"
+    assert result, "dinoid string must be non-empty"
+    return result
+
+
 def _colors(obj: t.Any) -> list[int]:
     out = [0] * 6
     getter = getattr(obj, "get_properties_by_name", None)
@@ -1052,7 +1077,10 @@ def _tamed_dict(
     mut_pts = _stat_array(status, "NumberOfMutationsAppliedTamed")
     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"))
+    is_asa = bool(getattr(save, "is_asa", False))
+    raw_id1 = _prop(obj, "DinoID1")
+    raw_id2 = _prop(obj, "DinoID2")
+    dino_id = _combine_dino_id(raw_id1, raw_id2)
     # 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).
@@ -1073,7 +1101,10 @@ def _tamed_dict(
     is_female = bool(_prop(obj, "bIsFemale", default=False))
     targeting_team = _int(_prop(obj, "TargetingTeam"))
     baby = bool(_prop(obj, "bIsBaby", default=False))
-    baby_age = _float(_prop(obj, "BabyAge"), default=1.0) if baby else 1.0
+    # A baby with no BabyAge property is a newborn (maturation 0), not an adult.
+    # Legacy reads BabyAge with default 0 (ContentCreature.cs:98). Non-babies
+    # stay at 1.0 -> maturation "100".
+    baby_age = _float(_prop(obj, "BabyAge"), default=0.0) if baby else 1.0
     father_id, father_name = _ancestor_parent(obj, "Male")
     mother_id, mother_name = _ancestor_parent(obj, "Female")
     tribe_name = _str(_prop(obj, "TribeName"))
@@ -1100,7 +1131,7 @@ def _tamed_dict(
         "mut-f": _int(_prop(obj, "RandomMutationsFemale")),
         "mut-m": _int(_prop(obj, "RandomMutationsMale")),
         "cryo": bool(_prop(obj, "IsInCryo", default=False)),
-        "dinoid": str(dino_id),
+        "dinoid": _dino_id_str(raw_id1, raw_id2, is_asa),
         "isMating": bool(_prop(obj, "bEnableTamedMating", default=False)),
         "isNeutered": bool(_prop(obj, "bNeutered", default=False)),
         "isClone": bool(_prop(obj, "bIsClone", default=False))
@@ -1109,7 +1140,9 @@ def _tamed_dict(
         "uploadedServer": _str(_prop(obj, "UploadedFromServerName")),
         "maturation": str(int(baby_age * 100)),
         **_flat_stats(mut_pts, "m"),
-        "traits": _traits(obj),
+        # Legacy emits tamed traits as a list of objects ([{"trait": <class>}]),
+        # not a flat string list (ContentPack.cs:723-735). Match that shape.
+        "traits": [{"trait": tr} for tr in _traits(obj)],
         "inventory": _inventory_items(obj, lookup),
         "father_id": father_id,
         "mother_id": mother_id,
@@ -1615,12 +1648,15 @@ def _wild_dict(
     obj: t.Any,
     status: t.Any,
     map_config: MapConfig | None,
+    is_asa: bool = False,
 ) -> dict[str, t.Any]:
     base_pts = _stat_array(status, "NumberOfLevelUpPointsApplied")
     base_level = _int(_prop(status, "BaseCharacterLevel"), default=1) or 1
     colors = _colors(obj)
     is_female = bool(_prop(obj, "bIsFemale", default=False))
-    dino_id = _combine_dino_id(_prop(obj, "DinoID1"), _prop(obj, "DinoID2"))
+    raw_id1 = _prop(obj, "DinoID1")
+    raw_id2 = _prop(obj, "DinoID2")
+    dino_id = _combine_dino_id(raw_id1, raw_id2)
     traits = _traits(obj)
     class_name = getattr(obj, "class_name", "") or ""
     tameable = _is_tameable(class_name, obj)
@@ -1632,7 +1668,7 @@ def _wild_dict(
         "lvl": base_level,
         **_flat_stats(base_pts),
         **{f"c{i}": colors[i] for i in range(6)},
-        "dinoid": str(dino_id),
+        "dinoid": _dino_id_str(raw_id1, raw_id2, is_asa),
         "tameable": tameable,
         # Legacy emits the first trait as a singular ``trait``; the full
         # CreatureTraits list is exposed alongside as ``traits``.
@@ -1647,8 +1683,9 @@ def _wild_dict(
 
 def export_wild(save: t.Any, map_config: MapConfig | None = None) -> list[dict[str, t.Any]]:
     objects = _world_objects(save, "get_wild_creatures", "wild_objects")
+    is_asa = bool(getattr(save, "is_asa", False))
     lookup = _save_lookup(save)
-    return [_wild_dict(obj, _status_for(obj, lookup), map_config) for obj in objects]
+    return [_wild_dict(obj, _status_for(obj, lookup), map_config, is_asa) for obj in objects]
 
 
 def _player_from_profile(
@@ -2210,7 +2247,10 @@ def _structure_dict(
         "struct": class_name,
         "name": box_name,
         "locked": locked,
-        "created": _structure_created(obj, save),
+        # Legacy CreatedDateTime is DateTime? -> a null interpolates to "" in
+        # the JSON, never JSON null. Match that (avoids a null-vs-string flip
+        # for structures whose creation time can't be resolved).
+        "created": _structure_created(obj, save) or "",
         "inventory": _inventory_items(obj, lookup),
         "decay_reset": bool(_prop(obj, "bHasResetDecayTime", default=False)),
         "last_ally_in_range": (

{arkparser-0.4.5 → arkparser-0.4.6}/arkparser/files/world_save.py

@@ -31,11 +31,11 @@ from pathlib import Path
 from uuid import UUID
 
 from ..common.binary_reader import BinaryReader
-from ..common.exceptions import ArkParseError
+from ..common.exceptions import ArkParseError, CorruptDataError
 from ..common.normalization import normalize_indexed_data, normalize_indexed_list
 from ..data_models import CryopodCreature
 from ..game_objects.container import GameObjectContainer
-from ..game_objects.game_object import GameObject
+from ..game_objects.game_object import MAX_OBJECT_COUNT, GameObject
 from ..game_objects.location import LocationData
 from ..properties.registry import read_properties
 
@@ -50,6 +50,23 @@ _ZERO_GUID = b"\x00" * 16
 _MAX_ASA_NAME_TABLE = 1_000_000
 
 
+def _checked_count(reader: BinaryReader, label: str, maximum: int = MAX_OBJECT_COUNT) -> int:
+    """Read a length-prefix int32 and reject corrupt/implausible values.
+
+    Power-of-10 rule 2 (fixed loop bounds): every count that drives a read
+    loop must be provably bounded. A negative or absurd count means a
+    misaligned/corrupt header; raise ``CorruptDataError`` (NOT ``assert`` -
+    asserts vanish under ``python -O``) rather than looping over billions of
+    phantom entries (OOM/hang).
+    """
+    if reader.remaining < 4:
+        raise CorruptDataError(f"{label}: truncated before count int32")
+    count = reader.read_int32()
+    if not 0 <= count <= maximum:
+        raise CorruptDataError(f"{label}: implausible count {count} (corrupt/misaligned read)")
+    return count
+
+
 @dataclass
 class EmbeddedData:
     """
@@ -540,25 +557,25 @@ class WorldSave:
         saved = reader.position
         reader.position = self._name_table_offset
 
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE name table")
         self.name_table = [reader.read_string() for _ in range(count)]
 
         reader.position = saved
 
     def _read_ase_data_files(self, reader: BinaryReader) -> None:
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE data files")
         self.data_files = [reader.read_string() for _ in range(count)]
 
     def _read_ase_embedded_data(self, reader: BinaryReader) -> None:
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE embedded data")
         self.embedded_data = [EmbeddedData.read(reader) for _ in range(count)]
 
     def _read_ase_data_files_object_map(self, reader: BinaryReader) -> None:
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE data-files object map")
         self.data_files_object_map = {}
         for _ in range(count):
             level = reader.read_int32()
-            name_count = reader.read_int32()
+            name_count = _checked_count(reader, "ASE data-files object names")
             names = [reader.read_string() for _ in range(name_count)]
             self.data_files_object_map.setdefault(level, []).append(names)
 
@@ -613,7 +630,7 @@ class WorldSave:
         return obj
 
     def _read_ase_objects(self, reader: BinaryReader) -> None:
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE objects")
         self.objects = [self._read_ase_object_header(reader, i) for i in range(count)]
 
     def _read_ase_object_properties(self, reader: BinaryReader) -> None:
@@ -701,7 +718,7 @@ class WorldSave:
         _unknown2 = reader.read_int32()
 
         # Data files (immediately follow the header; populate self.data_files).
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASA data files")
         self.data_files = []
         for _ in range(count):
             self.data_files.append(reader.read_string())
@@ -720,10 +737,12 @@ class WorldSave:
         # Where the gap is zero (TheIsland, Aberration, Extinction) the seek is
         # a no-op; where it drifts it recovers every leaked class name.
         if self.version >= 14:
-            assert 0 <= name_table_offset <= reader.size, (
-                f"ASA name-table offset {name_table_offset} out of range "
-                f"(blob size {reader.size})"
-            )
+            # Explicit raise (not assert) so the bound survives ``python -O``.
+            if not 0 <= name_table_offset <= reader.size:
+                raise CorruptDataError(
+                    f"ASA name-table offset {name_table_offset} out of range "
+                    f"(blob size {reader.size})"
+                )
             reader.position = name_table_offset
             self.name_table = self._read_asa_name_table(reader)
         else:
@@ -747,11 +766,7 @@ class WorldSave:
         user-placed-actor entries (``idx == 1``) on the v13 sequential path; it
         is unused on the v14 seek path.
         """
-        assert reader.remaining >= 4, "no room for ASA name-table count"
-        name_count = reader.read_int32()
-        assert 0 <= name_count <= _MAX_ASA_NAME_TABLE, (
-            f"implausible ASA name-table count {name_count} - misaligned read"
-        )
+        name_count = _checked_count(reader, "ASA name table", _MAX_ASA_NAME_TABLE)
         nt: dict[int, str] = {}
         for _ in range(name_count):
             idx = reader.read_int32()

{arkparser-0.4.5 → arkparser-0.4.6}/arkparser/properties/compound.py

@@ -418,8 +418,17 @@ def _read_array_elements(
         for _ in range(count):
             values.append(reader.read_int8())
     elif array_type == "ByteProperty":
-        for _ in range(count):
-            values.append(reader.read_uint8())
+        # ASE enum byte-arrays store each element as an 8-byte name-table
+        # reference, not a raw uint8. Legacy ArkArrayByteHandler discriminates
+        # on size: data_size > count+4 -> name refs, data_size == count+4 ->
+        # raw uint8. Mirror it so a name-valued byte array doesn't under-read
+        # and drift the cursor into the next property (the cluster-drift class).
+        if not is_asa and count > 0 and data_size > count + 4:
+            for _ in range(count):
+                values.append(read_name(reader, name_table))
+        else:
+            for _ in range(count):
+                values.append(reader.read_uint8())
     elif array_type == "FloatProperty":
         for _ in range(count):
             values.append(reader.read_float())

{arkparser-0.4.5 → arkparser-0.4.6}/arkparser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparser
-Version: 0.4.5
+Version: 0.4.6
 Summary: Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files
 Author: Vertyco
 License-Expression: MIT
@@ -212,14 +212,14 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `mut-f`, `mut-m` | legacy | **Ancestor-line totals.** `RandomMutationsFemale` and `RandomMutationsMale`, single integers counting the total number of mutations that occurred down the maternal and paternal ancestry lines respectively. These are *not* per-stat, they share the `-m` token with the per-stat mutation block below but mean a different thing. Kept under the legacy names for ASVExport parity. |
 | `cryo` | legacy | `True` for creatures embedded inside cryopod / soultrap / vivarium / dinoball items in the world save, `False` for actor-in-world tames. `export_tamed` walks `WorldSave.iter_cryopod_creatures()` and emits one ASV_Tamed record per embedded creature in addition to the actor-in-world tames; on busy PvE servers cryopodded tames are the majority of the roster (e.g. 10,277 of 11,054 on a live Ragnarok_WP). Cluster-uploaded tames also surface here (via `export_cluster_uploads`) with `cryo=True`. |
 | `ccc` | legacy | `"{x} {y} {z}"` from `LocationData` |
-| `dinoid` | legacy | string form of `id` |
+| `dinoid` | legacy | string form of the dino id. **ASA**: decimal of the combined 64-bit `id`. **ASE**: the two halves concatenated as signed-int32 decimals (`str(DinoID1) + str(DinoID2)`), matching `ASVExport`. |
 | `isMating` | legacy | `bEnableTamedMating` |
 | `isNeutered` | legacy | `bNeutered` |
 | `isClone` | legacy | `bIsClone` or `bIsCloneDino` |
 | `tamedServer` | legacy | `TamedOnServerName` |
 | `uploadedServer` | legacy | `UploadedFromServerName` |
-| `maturation` | legacy | `str(int(BabyAge * 100))` (string for legacy parity) |
-| `traits` | legacy | `CreatureTraits` (full list of mutation trait class names) |
+| `maturation` | legacy | `str(int(BabyAge * 100))` — integer maturation percent (a baby with no `BabyAge` is `0`, a newborn). Note: legacy emits the full float string (e.g. `"7.5131035"`); arkparser truncates to the integer percent. Semantically equal and the downstream consumer coerces to `int` either way. |
+| `traits` | legacy | `CreatureTraits` as a list of `{"trait": <class>}` objects (matches `ASVExport`'s shape, not a flat string list) |
 | `inventory` | legacy | items from `MyInventoryComponent.InventoryItems`. Each entry carries `itemId`, `qty`, `blueprint`, plus a full snake_case property dump flattened in at the top level (`id`, `rating`, `durability`, `quality`, `damage`, `armor`, `durability_max`, `hypo`, `hyper`, `clip_size`, `weight`, `crafter`, `crafter_tribe`, `skill_bonus`, `loaded_ammo`, `spoils_at`, `spoiled_at`, `c0`..`c5`, `egg_*`, etc). `item_stat_values` is unpacked into the universal 8-slot ARK map (slot 0 `gen_quality`, 1 `armor`, 2 `durability_max`, 3 `damage`, 4 `clip_size`, 5 `hypo`, 6 `weight`, 7 `hyperthermal_insulation`); raw uint16s scaled by the per-blueprint multiplier (which lives in the UE blueprint, not the save). Default / unset values are filtered (no `craft_queue=0`, `skin=-1`, `color_pre_skin=[0]*6`, NaN spoil timers, etc). When the item is a **cryopod / soultrap / vivarium / dinoball** with an embedded creature, the entry is enriched with `dino_id` (combined 64-bit id matching the corresponding `ASV_Tamed` record), `dino_creature` (species / class name), and `dino_name` (`TamedName` if set). Cryopods stored in containers (cryofridges, vaults, dedicated storage) get the same enrichment. |
 | `father_id`, `mother_id` | added | combined dino id from the first `DinoAncestors` entry (`null` when missing) |
 | `father_name`, `mother_name` | added | name strings from the first `DinoAncestors` entry |
@@ -256,7 +256,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 
 | Field | Origin | Source / formula |
 |---|---|---|
-| `id`, `dinoid` | legacy | `(DinoID1 << 32) \| DinoID2` and its string form |
+| `id`, `dinoid` | legacy | `id` = `(DinoID1 << 32) \| DinoID2`. `dinoid` = its string form on **ASA**, or `str(DinoID1) + str(DinoID2)` (signed int32) on **ASE**, matching `ASVExport`. |
 | `creature` | legacy | `GameObject.class_name` |
 | `sex` | legacy | `"Female"` if `bIsFemale` else `"Male"` |
 | `lvl` | legacy | `BaseCharacterLevel` (status) |

{arkparser-0.4.5 → arkparser-0.4.6}/pyproject.toml

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

{arkparser-0.4.5 → arkparser-0.4.6}/tests/test_cloud_inventory.py

@@ -4,7 +4,6 @@ Tests for cloud inventory (obelisk) parsing - both ASE and ASA formats.
 
 from pathlib import Path
 
-import pytest
 
 from arkparser import CloudInventory
 

{arkparser-0.4.5 → arkparser-0.4.6}/tests/test_profile.py

@@ -4,7 +4,6 @@ Tests for player profile parsing - both ASE and ASA formats.
 
 from pathlib import Path
 
-import pytest
 
 from arkparser import Profile
 

arkparser-0.4.6/tests/test_review_fixes.py

@@ -0,0 +1,270 @@
+"""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.data_models import UploadedCreature, UploadedItem
+from arkparser.export import (
+    _SyntheticGameObject,
+    _dino_id_str,
+    _float,
+    _gps_payload,
+    _structure_dict,
+    _tamed_dict,
+    _wild_dict,
+)
+from arkparser.files.world_save import _checked_count
+from arkparser.game_objects.game_object import MAX_OBJECT_COUNT, read_object_list
+from arkparser.properties.compound import _read_array_elements
+
+
+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
+
+
+# --- code-review (max): tamed `traits` shape is legacy object-list -----------
+
+def test_tamed_traits_emitted_as_objects() -> None:
+    # Legacy ASVExport emits tamed traits as [{"trait": <class>}], not [str]
+    # (ContentPack.cs:723-735).
+    actor = _SyntheticGameObject(
+        "Dodo_C", {"CreatureTraits": ["Rabid_Tier1", "Aggressive_Tier2"]}
+    )
+    rec = _tamed_dict(actor, _status(), {}, None)
+    assert rec["traits"] == [{"trait": "Rabid_Tier1"}, {"trait": "Aggressive_Tier2"}]
+
+
+def test_tamed_traits_empty_list_when_absent() -> None:
+    rec = _tamed_dict(_SyntheticGameObject("Dodo_C", {}), _status(), {}, None)
+    assert rec["traits"] == []
+
+
+# --- code-review (max): ASE/ASA `dinoid` string form ------------------------
+
+def test_tamed_dinoid_ase_is_decimal_concat() -> None:
+    # ASE (save absent -> is_asa False): str(DinoID1) + str(DinoID2).
+    actor = _SyntheticGameObject("Dodo_C", {"DinoID1": 475230717, "DinoID2": 97170314})
+    rec = _tamed_dict(actor, _status(), {}, None)
+    assert rec["dinoid"] == "47523071797170314"
+
+
+def test_tamed_dinoid_asa_is_combined_id() -> None:
+    # ASA: decimal of the combined 64-bit id (== the positive `id`).
+    actor = _SyntheticGameObject("Dodo_C", {"DinoID1": 475230717, "DinoID2": 97170314})
+    save = types.SimpleNamespace(is_asa=True)
+    rec = _tamed_dict(actor, _status(), {}, None, save=save)
+    assert rec["dinoid"] == "2041100387666801546"
+    assert rec["dinoid"] == str(rec["id"])
+
+
+def test_wild_dinoid_ase_vs_asa() -> None:
+    obj = _SyntheticGameObject("Raptor_C", {"DinoID1": 475230717, "DinoID2": 97170314})
+    assert _wild_dict(obj, _status(), None, False)["dinoid"] == "47523071797170314"
+    assert _wild_dict(obj, _status(), None, True)["dinoid"] == "2041100387666801546"
+
+
+def test_dino_id_str_ase_halves_are_signed_int32() -> None:
+    # ASE concat reinterprets each uint32 half as signed int32 (matches C#
+    # GetPropertyValue<int>); both-zero collapses to "0" not "00".
+    assert _dino_id_str(0x90000000, 5, is_asa=False) == "-18790481925"
+    assert _dino_id_str(0, 0, is_asa=False) == "0"
+    assert _dino_id_str(0, 0, is_asa=True) == "0"
+
+
+# --- code-review (max): maturation newborn default --------------------------
+
+def test_tamed_maturation_newborn_is_zero() -> None:
+    # A baby with no BabyAge is a newborn -> "0" (legacy default), not "100".
+    baby = _SyntheticGameObject("Dodo_C", {"bIsBaby": True})
+    assert _tamed_dict(baby, _status(), {}, None)["maturation"] == "0"
+
+
+def test_tamed_maturation_adult_is_hundred() -> None:
+    adult = _SyntheticGameObject("Dodo_C", {})
+    assert _tamed_dict(adult, _status(), {}, None)["maturation"] == "100"
+
+
+# --- code-review (max): structure `created` is "" not null ------------------
+
+def test_structure_created_empty_string_when_no_anchor() -> None:
+    # Legacy CreatedDateTime is DateTime? -> interpolates to "" (never null).
+    struct = _SyntheticGameObject("Wall_C", {})
+    assert _structure_dict(struct, None, {}, None)["created"] == ""
+
+
+# --- code-review (max): non-finite floats never crash strict JSON -----------
+
+def test_uploaded_item_nan_rating_is_legacy_sentinel() -> None:
+    item = UploadedItem.from_ark_data(
+        {"ArkTributeItem": {"ItemRating": float("nan"), "ItemDurability": float("inf")}}
+    )
+    assert item.rating == 0.0001  # legacy ContentItem.cs:62 substitution
+    assert item.durability == 0.0
+    json.dumps(item.to_dict())  # strict serialization must not raise
+
+
+def test_uploaded_creature_nan_experience_zeroed() -> None:
+    c = UploadedCreature.from_ark_data({"DinoExperiencePoints": float("nan")})
+    assert c.experience == 0.0
+
+
+# --- code-review (max): ASE byte-array enum-name discriminator (C1) ----------
+
+def test_byte_array_raw_uint8_path_unchanged() -> None:
+    # data_size == count+4 -> raw uint8 (common case; must not regress).
+    reader = BinaryReader.from_bytes(b"\x0a\x14\x1e")
+    vals = _read_array_elements(reader, "ByteProperty", 3, 3 + 4, "Foo", False, None)
+    assert vals == [10, 20, 30]
+
+
+def test_byte_array_enum_name_path_no_drift() -> None:
+    # data_size > count+4 -> 8-byte name refs, not 1-byte uint8 (would drift).
+    def _ref(index: int, instance: int) -> bytes:
+        return index.to_bytes(4, "little") + instance.to_bytes(4, "little")
+
+    reader = BinaryReader.from_bytes(_ref(1, 0) + _ref(2, 0))
+    vals = _read_array_elements(reader, "ByteProperty", 2, 2 * 8 + 4, "Colors", False, ["Foo", "Bar"])
+    assert vals == ["Foo", "Bar"]
+    assert reader.remaining == 0  # consumed 8 bytes/elem -> no cursor drift
+
+
+# --- code-review (max): corrupt count caps survive python -O (D1/D2) ---------
+
+def test_checked_count_rejects_absurd_and_negative() -> None:
+    absurd = BinaryReader.from_bytes((MAX_OBJECT_COUNT + 1).to_bytes(4, "little"))
+    with pytest.raises(CorruptDataError):
+        _checked_count(absurd, "test")
+    negative = BinaryReader.from_bytes((-1).to_bytes(4, "little", signed=True))
+    with pytest.raises(CorruptDataError):
+        _checked_count(negative, "test")
+
+
+def test_checked_count_accepts_valid() -> None:
+    assert _checked_count(BinaryReader.from_bytes((42).to_bytes(4, "little")), "test") == 42

{arkparser-0.4.5 → arkparser-0.4.6}/tests/test_tribe.py

@@ -4,7 +4,6 @@ Tests for tribe (.arktribe) parsing - both ASE and ASA formats.
 
 from pathlib import Path
 
-import pytest
 
 from arkparser import Tribe
 

{arkparser-0.4.5 → arkparser-0.4.6}/tests/test_world_save.py

@@ -39,7 +39,7 @@ import pytest
 from arkparser import WorldSave
 from arkparser.game_objects.game_object import GameObject
 from arkparser.game_objects.location import LocationData
-from arkparser.export import _ancestor_parent, _combine_dino_id
+from arkparser.export import _ancestor_parent
 
 _EXAMPLES = Path(__file__).parent.parent / "references" / "examples"
 

arkparser-0.4.5/tests/test_review_fixes.py

@@ -1,138 +0,0 @@
-"""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