arkparse 0.5.1__tar.gz → 0.5.3__tar.gz

{arkparse-0.5.1 → arkparse-0.5.3}/.gitignore

@@ -188,5 +188,6 @@ temp
 .venv**
 arkparse-fast-core/**
 /arkparse-fast-core
-
-**.zip
+.serena/
+**.zip
+.claude/

{arkparse-0.5.1 → arkparse-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparse
-Version: 0.5.1
+Version: 0.5.3
 Summary: A package to parse and modify ark save files
 Project-URL: Homepage, https://github.com/VincentHenauGithub/ark-save-parser
 Author-email: Vincent Henau <vincent.henau.github@gmail.com>

{arkparse-0.5.1 → arkparse-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arkparse"
-version = "0.5.1"
+version = "0.5.3"
 dependencies = [
     "rcon>=2.4.9",
     "numpy>=2.3.2",

{arkparse-0.5.1 → arkparse-0.5.3}/src/arkparse/api/json_api.py

@@ -455,7 +455,12 @@ class JsonApi:
                 try:
                     obj_uuid = SaveConnection.byte_array_to_uuid(row[0])
                     byte_buffer = ArkBinaryParser(row[1], self.save.save_context)
-                    class_name = byte_buffer.read_name()
+                    # Use the string-name-aware reader: some objects store their
+                    # class as an inline string instead of a name-table id, which
+                    # a raw read_name() can't resolve (raises when generate_unknown
+                    # is off). Those are never items, so they fall through the
+                    # filter below.
+                    class_name, *_ = ArkGameObject.read_name(obj_uuid, byte_buffer)
 
                     if "/PrimalItemArmor_" not in class_name and \
                             "/PrimalItem_" not in class_name and \

{arkparse-0.5.1 → arkparse-0.5.3}/src/arkparse/logging/ark_save_logger.py

@@ -52,6 +52,16 @@ class ArkSaveLogger:
     # Use _get_struct_path() for thread-safe access
     current_struct_path = []
     _allow_invalid_objects = None
+    # Governs mod-namespace objects (not /Game/ or /Script/). Defaults to True
+    # (skip & continue) for backward compatibility; set to False to hard-fail.
+    _allow_invalid_mod_objects = None
+    # Optional callback invoked when an object fails to parse. Signature:
+    #   (obj_uuid, class_name, byte_buffer, error) -> None
+    # Used by tooling (e.g. the testbench) to capture failing objects for debug.
+    _object_failure_handler = None
+    # Optional callback invoked on a (non-fatal) struct size mismatch. Signature:
+    #   (struct_type, data_size, start_position, end_position, byte_buffer) -> None
+    _struct_mismatch_handler = None
     _worker_logging_enabled = None  # Whether logging is enabled in worker threads
     _file = ""
     _byte_buffer = None
@@ -140,10 +150,13 @@ class ArkSaveLogger:
                 }
                 ArkSaveLogger._file_viewer_enabled = True
                 ArkSaveLogger._worker_logging_enabled = False
+                ArkSaveLogger._allow_invalid_objects = True
+                ArkSaveLogger._allow_invalid_mod_objects = True
                 config = {
                     "levels": ArkSaveLogger._log_level_states,
                     "fve": False,
                     "allow_invalid": True,
+                    "allow_invalid_mod": True,
                     "worker_logging": False
                 }
                 write_config_file(ArkSaveLogger.__LOG_CONFIG_FILE_NAME, config)
@@ -151,6 +164,7 @@ class ArkSaveLogger:
                 ArkSaveLogger._log_level_states = config["levels"]
                 ArkSaveLogger._file_viewer_enabled = config["fve"]
                 ArkSaveLogger._allow_invalid_objects = config["allow_invalid"]
+                ArkSaveLogger._allow_invalid_mod_objects = config.get("allow_invalid_mod", True)
                 ArkSaveLogger._worker_logging_enabled = config.get("worker_logging", False)
             # Update cached parser_log state for fast checks
             ArkSaveLogger._parser_log_enabled = (
@@ -220,6 +234,69 @@ class ArkSaveLogger:
             global_config["allow_invalid"] = state
             write_config_file(ArkSaveLogger.__LOG_CONFIG_FILE_NAME, global_config)
 
+    @staticmethod
+    def allow_invalid_mod_objects(state: bool = True, set_globally: bool = False):
+        """Governs parsing failures for mod-namespace objects (anything whose
+        class is not under /Game/ or /Script/). When False, such failures are
+        reraised instead of skipped. Defaults to True (skip & continue)."""
+        if ArkSaveLogger._allow_invalid_mod_objects is None:
+            ArkSaveLogger.__init_config()
+
+        ArkSaveLogger._allow_invalid_mod_objects = state
+
+        if set_globally:
+            global_config = read_config_file(ArkSaveLogger.__LOG_CONFIG_FILE_NAME)
+            global_config["allow_invalid_mod"] = state
+            write_config_file(ArkSaveLogger.__LOG_CONFIG_FILE_NAME, global_config)
+
+    @staticmethod
+    def set_object_failure_handler(handler):
+        """Register a callback invoked whenever an object fails to parse.
+
+        The handler receives ``(obj_uuid, class_name, byte_buffer, error)``. Pass
+        ``None`` to clear it. Exceptions raised by the handler are swallowed so
+        debug tooling can never break parsing. Intended for capturing failing
+        objects (binary + structured dump) for offline debugging.
+        """
+        ArkSaveLogger._object_failure_handler = handler
+
+    @staticmethod
+    def _notify_object_failure(obj_uuid, class_name, byte_buffer, error, **kwargs):
+        """Forward a parse failure to the registered handler.
+
+        ``kwargs`` carries optional context (e.g. ``kind`` of "game"/"archive" and
+        a ``reload_hint`` dict) so the handler can capture and reload different
+        object types appropriately. Handlers should accept ``**kwargs``.
+        """
+        handler = ArkSaveLogger._object_failure_handler
+        if handler is None:
+            return
+        try:
+            handler(obj_uuid, class_name, byte_buffer, error, **kwargs)
+        except Exception as e:  # never let debug tooling break parsing
+            ArkSaveLogger.warning_log(f"object_failure_handler raised: {e}")
+
+    @staticmethod
+    def set_struct_mismatch_handler(handler):
+        """Register a callback invoked on a non-fatal struct size mismatch (a
+        struct parsed as a property list that didn't consume exactly data_size).
+
+        The handler receives ``(struct_type, data_size, start_position,
+        end_position, byte_buffer)``. Pass ``None`` to clear it. Exceptions are
+        swallowed. Intended for debug tooling to record under-/over-read structs.
+        """
+        ArkSaveLogger._struct_mismatch_handler = handler
+
+    @staticmethod
+    def _notify_struct_mismatch(struct_type, data_size, start_position, end_position, byte_buffer):
+        handler = ArkSaveLogger._struct_mismatch_handler
+        if handler is None:
+            return
+        try:
+            handler(struct_type, data_size, start_position, end_position, byte_buffer)
+        except Exception as e:  # never let debug tooling break parsing
+            ArkSaveLogger.warning_log(f"struct_mismatch_handler raised: {e}")
+
     @staticmethod
     def enable_worker_logging(state: bool = True, set_globally: bool = False):
         """Enable or disable logging in parallel worker threads.

{arkparse-0.5.1 → arkparse-0.5.3}/src/arkparse/object_model/ark_game_object.py

@@ -45,6 +45,8 @@ class ArkGameObject(ArkPropertyContainer):
         self.uuid = uuid
         self.blueprint = blueprint
         string_name = False
+        string_names: List[str] = []
+        string_name_offsets: List[int] = []
         super().__init__()
         if binary_reader:
             ArkSaveLogger.set_file(binary_reader, "debug.bin")
@@ -55,7 +57,7 @@ class ArkGameObject(ArkPropertyContainer):
                     self.uuid2: UUID = None
                     binary_reader.set_position(0)
 
-                    self.blueprint, string_name = ArkGameObject.read_name(uuid, binary_reader)
+                    self.blueprint, string_name, string_names, string_name_offsets = ArkGameObject.read_name(uuid, binary_reader)
                     ArkSaveLogger.parser_log(f"Read Blueprint: {self.blueprint} (String name: {string_name})")
 
                     sContext : SaveContext = binary_reader.save_context
@@ -69,6 +71,14 @@ class ArkGameObject(ArkPropertyContainer):
                 binary_reader.validate_uint32(0)
                 if string_name:
                     binary_reader.read_uint16()
+                    # Names embedded in a string-name header are stored as
+                    # strings (never as name-table refs), mirroring what the
+                    # regular names block below would produce.
+                    self.names = string_names
+                    self.name_metadata = [
+                        _NameMetadata(name, offset, True)
+                        for name, offset in zip(string_names, string_name_offsets)
+                    ]
 
             try:
                 if not (no_header or string_name):
@@ -250,6 +260,8 @@ class ArkGameObject(ArkPropertyContainer):
     def read_name(obj_uuid: UUID, reader: ArkBinaryParser) -> str:
         reader.set_position(0)
         string_name = False
+        extra_names: List[str] = []
+        extra_offsets: List[int] = []
 
         try:
             class_name = reader.read_name()
@@ -260,18 +272,26 @@ class ArkGameObject(ArkPropertyContainer):
             try:
                 unknow_id = reader.read_uint32()
                 reader.validate_uint64(0)
-                reader.read_int()
+                name_count = reader.read_int()
                 class_name = reader.read_string()
                 # reader.validate_uint32(0)
                 string_name = True
+                # The string-name header carries a name count: the first string is
+                # the class, any further strings are the object's names (e.g. the
+                # instance name of a DeathItemCache) that the name-table format
+                # would store separately. Consume them so the trailing padding
+                # lines up (otherwise validate_uint32(0) hits the next length).
+                for _ in range(max(0, name_count - 1)):
+                    extra_offsets.append(reader.position + 4)
+                    extra_names.append(reader.read_string())
                 ArkSaveLogger.parser_log(f"Object {obj_uuid} has string class name {class_name} instead of name table reference")
             except Exception as e:
                 ArkSaveLogger.error_log(f"Error reading class name for object {obj_uuid}: {e}")
                 reader.structured_print(to_default_file=True)
                 # input("Press Enter to continue...")
                 class_name = "UnknownClass"
-                
-        return class_name, string_name
+
+        return class_name, string_name, extra_names, extra_offsets
     
     def get_short_name(self) -> str:
         to_strip_end = [

{arkparse-0.5.1 → arkparse-0.5.3}/src/arkparse/parsing/ark_archive.py

@@ -73,6 +73,12 @@ class ArkArchive:
             except Exception as e:
                 ArkSaveLogger.error_log(f"Error reading properties for object \'{obj.class_name}\' at {self.data.get_position()}: {e}")
                 self.data.structured_print()
+                # Notify any registered debug handler (e.g. the testbench dumper).
+                # Archives reload from their raw bytes via ArkArchive(data, from_store).
+                ArkSaveLogger._notify_object_failure(
+                    None, obj.class_name, self.data, e,
+                    kind="archive", reload_hint={"from_store": from_store},
+                )
                 raise e
             ArkSaveLogger.exit_struct()
 

{arkparse-0.5.1 → arkparse-0.5.3}/src/arkparse/parsing/ark_property.py

@@ -173,7 +173,7 @@ class ArkProperty:
     # Public API
     # ---------------------------------------------------------------------------------------------
     @staticmethod
-    def read_property(byte_buffer: "ArkBinaryParser", in_array: bool = False) -> Optional["ArkProperty"]:
+    def read_property(byte_buffer: "ArkBinaryParser", in_array: bool = False, struct_end: int = -1) -> Optional["ArkProperty"]:
         name_position = byte_buffer.get_position()
         value_position = 0
         byte_buffer.save_context.generate_unknown = True
@@ -185,7 +185,12 @@ class ArkProperty:
             ArkSaveLogger.parser_log("Exiting struct (None marker) (pos = " + str(byte_buffer.get_position()) + " (hex: " + hex(byte_buffer.get_position()) + "))")
             ArkSaveLogger.exit_struct()
 
-            if byte_buffer.size() - byte_buffer.position >= 4 and byte_buffer.peek_int() == 0:
+            # Only skip the 4 trailing zeros if we haven't already reached the
+            # declared struct boundary. When struct_end is known and we're right
+            # at it, those zeros belong to the outer stream, not this struct.
+            if (struct_end == -1 or byte_buffer.position < struct_end) \
+                    and byte_buffer.size() - byte_buffer.position >= 4 \
+                    and byte_buffer.peek_int() == 0:
                 byte_buffer.skip_bytes(4)
             return None
 
@@ -291,6 +296,18 @@ class ArkProperty:
         if key_type == ArkValueType.Struct:
             value_type = bb.read_name()
         else:
+            if key_type == ArkValueType.Byte:
+                # Enum-keyed map (e.g. TMap<TEnumAsByte<EFoo>, ...>): the key's
+                # enum type is serialized as a descriptor block before the value
+                # type: [enum name][int][enum path][int]. Consume it so the value
+                # type is read from the correct offset.
+                enum_key_type = bb.read_name()
+                bb.read_int()
+                enum_key_path = bb.read_name()
+                bb.read_int()
+                ArkSaveLogger.parser_log(
+                    f"Enum-keyed map: enum={enum_key_type} ({enum_key_path})"
+                )
             value_type = bb.read_value_type_by_name()
             struct_names = bb.read_int()
             if struct_names > 0:
@@ -342,7 +359,13 @@ class ArkProperty:
     @staticmethod
     def read_struct_map(key_type: ArkValueType, bb: "ArkBinaryParser", map_name: str) -> "ArkProperty":
         props: List[ArkProperty] = []
-        key_name = ArkProperty.read_property_value(key_type, bb)
+        if key_type == ArkValueType.Byte:
+            # Enum-keyed map entry: the key is the enum value name (e.g.
+            # E_ActorType_AAT::NewEnumerator0), serialized as a name reference
+            # rather than a single byte.
+            key_name = bb.read_name()
+        else:
+            key_name = ArkProperty.read_property_value(key_type, bb)
         with log_block(f"Map({key_name}:{map_name})"):
             while bb.has_more():
                 p = ArkProperty.read_property(bb)
@@ -374,6 +397,16 @@ class ArkProperty:
     
         return prop
 
+    @staticmethod
+    def _has_struct_reader(struct_type: str) -> bool:
+        """Whether this struct type has a dedicated (fixed-layout) reader.
+
+        Types without one are read generically as a property list; see
+        ``_read_struct_body`` and the guarded array backup in
+        ``read_array_property``.
+        """
+        return ArkStructType.from_type_name(struct_type) in _STRUCT_READERS
+
     @staticmethod
     def read_array_property(key: str, type_: str, position: int, bb: "ArkBinaryParser", data_size: int) -> Tuple["ArkProperty", int]:
         # V14 no position in array
@@ -405,31 +438,51 @@ class ArkProperty:
                 bb.set_position(bb.position - 4)
 
             array_items = bb.read_uint32()
+            array_end = data_start_position + data_size
 
-            # if array_content_type == "PrimalCharacterStatusValueModifier":
-            #     ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, True)
+            # Structs without a dedicated reader are read generically as a property
+            # list (see _read_struct_body). That backup is reliable for well-formed,
+            # None-terminated property-list structs but can't be guaranteed for an
+            # arbitrary packed layout, so guard it: if a generic element read raises,
+            # recover by skipping to the array's known end and record the type for
+            # follow-up rather than failing the whole object. A dedicated reader
+            # raising is a real bug, so let that propagate.
+            has_reader = ArkProperty._has_struct_reader(array_content_type)
 
             with log_block(f"Arr({array_content_type})"):
                 ArkSaveLogger.parser_log(
                     f"[STRUCT ARRAY: key='none'; nr_of_value={array_items}; type={array_content_type}; bin_length={data_size}]"
                 )
-                struct_array = [
-                    ArkProperty.read_struct_property(bb, data_size, array_content_type, True)[0]
-                    for _ in range(array_items)
-                ]
+                struct_array = []
+                try:
+                    for _ in range(array_items):
+                        struct_array.append(
+                            ArkProperty.read_struct_property(bb, data_size, array_content_type, True)[0]
+                        )
+                except Exception as exc:
+                    if has_reader:
+                        raise
+                    ArkSaveLogger.warning_log(
+                        f"Generic read of struct array '{array_content_type}' failed after "
+                        f"{len(struct_array)}/{array_items} element(s): {exc}; skipping to end of array"
+                    )
+                    ArkSaveLogger._notify_struct_mismatch(
+                        array_content_type, data_size, data_start_position, bb.position, bb
+                    )
+                    bb.set_position(array_end)
 
             prop = ArkProperty(key, type_, position, 0, struct_array)
-            if bb.position != data_start_position + data_size:
+            if bb.position != array_end:
+                # The read didn't consume exactly the declared size. Record the
+                # mismatch (the testbench captures these) and realign to the end.
                 ArkSaveLogger.warning_log(
-                    f"Array read incorrectly, bytes left to read: {data_start_position + data_size - bb.position}, current position: {bb.position}"
+                    f"Array of struct '{array_content_type}' read incorrectly, "
+                    f"bytes off: {array_end - bb.position}; realigning to end of array"
                 )
-                ArkSaveLogger.warning_log(f"Skipping to the end of the struct, type: {array_content_type}")
-                bb.set_position(data_start_position + data_size)
-                bb.structured_print(to_default_file=True)
-                ArkSaveLogger.open_hex_view(True)
-
-            # if array_content_type == "PrimalCharacterStatusValueModifier":
-            #     ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, False)
+                ArkSaveLogger._notify_struct_mismatch(
+                    array_content_type, data_size, data_start_position, bb.position, bb
+                )
+                bb.set_position(array_end)
 
             return prop, start_values_pos
 
@@ -511,7 +564,12 @@ class ArkProperty:
         ark_struct_type = ArkStructType.from_type_name(struct_type)
         
         if (ark_struct_type is not None) or in_array:
-            if in_array and bb.peek_name() == "None":
+            # Known fixed-layout structs (LinearColor/Vector/Color/...) are packed
+            # primitives with no None terminator. In archive parsing there is no name
+            # table, so peek_name() falls back to read_string() and would mis-read their
+            # packed float bytes as a string length, overflowing the buffer. Skip the
+            # None probe for these and let the dedicated reader consume the exact bytes.
+            if in_array and ark_struct_type not in _STRUCT_READERS and bb.peek_name() == "None":
                 ArkSaveLogger.parser_log("Exiting struct (None marker)")
                 return bb.read_name()
             if data_size <= 4:
@@ -521,34 +579,38 @@ class ArkProperty:
                 ArkSaveLogger.parser_log(f"Reading struct {struct_type} with data size {data_size}")
                 return _STRUCT_READERS[ark_struct_type](bb, data_size)
             if in_array:
+                # No dedicated reader for this struct type. Fall through to the
+                # generic property-list read below — the designed backup for unknown
+                # structs in arrays. It reads cleanly for well-formed, None-terminated
+                # property-list structs, and read_array_property validates the array's
+                # total size and recovers from any type it can't fully consume, so
+                # this is not by itself an error. Record the type once (quietly) so it
+                # is discoverable without the noise of a per-type warning.
                 if struct_type not in UNSUPPORTED_STRUCTS:
-                    ArkSaveLogger.warning_log(f"Unsupported struct type {struct_type} in array")
+                    ArkSaveLogger.parser_log(
+                        f"No dedicated reader for struct '{struct_type}' in array; "
+                        f"reading generically as a property list"
+                    )
                     UNSUPPORTED_STRUCTS.append(struct_type)
-                
-                # uncomment the lines below if you want to make objects of unknown structs
-                # ArkSaveLogger.parser_log(f"Reading struct {struct_type} as array")
-                # bb.structured_print(to_default_file=True)
-                # bb.store()
-                # ArkSaveLogger.error_log(f"Unsupported struct type {struct_type} in array")
-                # ArkSaveLogger.open_hex_view(True)
-                # raise ValueError(f"Unsupported struct type {struct_type}")
 
         ArkSaveLogger.parser_log(f"Reading struct {struct_type} with data size {data_size} as property list at position {bb.get_position()}")
         # Fallback: struct as property list
         position = bb.get_position()
-        props = ArkProperty.read_struct_properties(bb)
+        props = ArkProperty.read_struct_properties(bb, struct_end=position + data_size)
         if bb.get_position() != position + data_size and not in_array:
             ArkSaveLogger.warning_log(f"WARNING: Struct reading position mismatch for type {struct_type}")
             ArkSaveLogger.warning_log(
                 f"StructType: {struct_type}, DataSize: {data_size}, Position: {position}, CurrentPosition: {bb.get_position()}"
             )
+            # Notify any registered debug handler (e.g. the testbench recorder).
+            ArkSaveLogger._notify_struct_mismatch(struct_type, data_size, position, bb.get_position(), bb)
             bb.set_position(position + data_size)
         return props
 
     @staticmethod
-    def read_struct_properties(bb: "ArkBinaryParser") -> ArkPropertyContainer:
+    def read_struct_properties(bb: "ArkBinaryParser", struct_end: int = -1) -> ArkPropertyContainer:
         props: List[ArkProperty] = []
-        struct_property = ArkProperty.read_property(bb)
+        struct_property = ArkProperty.read_property(bb, struct_end=struct_end)
         if struct_property is not None:
             ArkSaveLogger.parser_log(
                 f"Struct properties: {struct_property.name} {struct_property.type} {struct_property.value}"
@@ -556,7 +618,7 @@ class ArkProperty:
         while struct_property:
             props.append(struct_property)
             if bb.has_more():
-                struct_property = ArkProperty.read_property(bb)
+                struct_property = ArkProperty.read_property(bb, struct_end=struct_end)
                 if struct_property is not None:
                     ArkSaveLogger.parser_log(
                         f"Struct properties: {struct_property.name} {struct_property.type} {struct_property.value}"

{arkparse-0.5.1 → arkparse-0.5.3}/src/arkparse/parsing/struct/ark_custom_item_data.py

@@ -92,7 +92,19 @@ class ArkCustomItemData:
         #         ark_binary_data.validate_uint32(0)
         #         self.skins.append([bp, shorthand])
 
-        ark_binary_data.validate_name("None")        
+        ark_binary_data.validate_name("None")
+
+        # Some modded CustomItemData (e.g. the Cryopods mod) append extra empty
+        # trailing sections, each serialized as a [uint32 0][None] pair. Vanilla
+        # data has none of these, so this loop is a no-op there; the next array
+        # element starts with a real name ("CustomDataBytes") whose first 4 bytes
+        # are non-zero, which stops the loop.
+        while (ark_binary_data.size() - ark_binary_data.position) >= 12 \
+                and ark_binary_data.peek_int() == 0 \
+                and ark_binary_data.peek_name(4) == "None":
+            ark_binary_data.read_uint32()   # 0
+            ark_binary_data.read_name()     # None
+            ArkSaveLogger.parser_log("Consumed trailing [0][None] padding in CustomItemData")
 
         ArkSaveLogger.parser_log(f"CustomItemData of type {self.custom_data_name} read successfully, total size: {total_size} bytes")
         for string in self.strings:
@@ -335,10 +347,17 @@ class ArkCustomItemData:
         nr_of_items = ark_binary_data.read_uint32()
         soft_classes = []
 
-        while ark_binary_data.peek_int() != 0:
-            obj_name = ark_binary_data.read_name()
-            soft_classes.append(obj_name)
-        ark_binary_data.validate_uint32(0)
+        # Each soft-class entry is an FSoftObjectPath.
+        # - With name table (game saves): single FName (name_id + always_zero) + SubPathString.
+        # - Without name table (archives, UE 5.5): FTopLevelAssetPath — PackageName string
+        #   + AssetName string — followed by SubPathString.
+        has_name_table = ark_binary_data.save_context.has_name_table()
+        for _ in range(nr_of_items):
+            pkg_name = ark_binary_data.read_name()    # PackageName (or full path when name table)
+            if not has_name_table:
+                ark_binary_data.read_name()           # AssetName (archives only)
+            ark_binary_data.read_string()             # SubPathString (usually empty)
+            soft_classes.append(pkg_name)
 
         return soft_classes
 

{arkparse-0.5.1 → arkparse-0.5.3}/src/arkparse/saves/save_connection.py

@@ -182,7 +182,7 @@ class SaveConnection:
             obj_uuid = _fast_uuid_from_bytes(key_bytes)
             try:
                 reader = ArkBinaryParser(value_bytes, self.save_context)
-                class_name, _ = ArkGameObject.read_name(obj_uuid, reader)
+                class_name, *_ = ArkGameObject.read_name(obj_uuid, reader)
                 self._class_cache[obj_uuid] = class_name
             except Exception:
                 pass
@@ -192,7 +192,7 @@ class SaveConnection:
             return self._class_cache[obj_uuid]
         bin = self.get_game_obj_binary(obj_uuid)
         reader = ArkBinaryParser(bin, self.save_context)
-        class_name, string_name = ArkGameObject.read_name(obj_uuid, reader)
+        class_name, *_ = ArkGameObject.read_name(obj_uuid, reader)
         self._class_cache[obj_uuid] = class_name
         return class_name
 
@@ -402,7 +402,10 @@ class SaveConnection:
             cursor = conn.execute(query)
             for row in cursor:
                 byte_buffer = ArkBinaryParser(row[0], self.save_context)
-                class_name = byte_buffer.read_name()
+                # String-name-aware read: some objects store their class as an
+                # inline string instead of a name-table id, which a raw
+                # read_name() can't resolve (raises when generate_unknown is off).
+                class_name, *_ = ArkGameObject.read_name(None, byte_buffer)
                 if class_name not in classes:
                     classes.append(class_name)
         return classes
@@ -452,7 +455,7 @@ class SaveConnection:
         bin = self.get_game_obj_binary(obj_uuid)
         reader = ArkBinaryParser(bin, self.save_context)
 
-        class_name, string_name = ArkGameObject.read_name(obj_uuid, reader)
+        class_name, *_ = ArkGameObject.read_name(obj_uuid, reader)
 
         obj = SaveConnection.parse_as_predefined_object(obj_uuid, class_name, reader)
 
@@ -488,7 +491,7 @@ class SaveConnection:
                     continue
 
                 byte_buffer = ArkBinaryParser(binary_data, self.save_context)
-                class_name, _ = ArkGameObject.read_name(obj_uuid, byte_buffer)
+                class_name, *_ = ArkGameObject.read_name(obj_uuid, byte_buffer)
 
                 if reader_config.blueprint_name_filter and not reader_config.blueprint_name_filter(class_name):
                     continue
@@ -609,10 +612,17 @@ class SaveConnection:
                 ArkSaveLogger.warning_log(f"Error parsing object {obj_uuid} of type {class_name}, skipping...")
             else:
                 byte_buffer.structured_print(to_default_file=True)
+                if ArkSaveLogger._allow_invalid_mod_objects is False:
+                    byte_buffer.find_names(type=2)
+                    ArkSaveLogger.error_log(f"Error parsing mod object {obj_uuid} of type {class_name}: {e}")
+                    reraise = True
                 ArkSaveLogger.warning_log(f"Error parsing non-standard object of type {class_name}")
 
                 # input("Press Enter to continue...")
 
+            # Notify any registered debug handler (e.g. the testbench dumper).
+            ArkSaveLogger._notify_object_failure(obj_uuid, class_name, byte_buffer, e, kind="game")
+
             SaveConnection.failed_parses[class_name] = SaveConnection.failed_parses.get(class_name, 0) + 1
             ArkSaveLogger.warning_log(f"Failed parses for this class: {SaveConnection.failed_parses[class_name]}")