Skip objects whose bodies won't parse instead of failing the load

[valentinps]

Closes #30.

The bug

The reported save is modded (Modular Load Balancers, FicsitWiremod and others). 106 of its 37,958 objects would not re-parse, and a single one of those sank the entire load:

Failed to load save: object re-parse failed during index build:
object at (3946, 5836): String decode failure at offset 24369724 of length 3670015

All 106 are Modular Load Balancer buildables (80 Filtered_Output, 24 Input, 2 Output). Each carries an LBBalancerData struct holding mIndexMapping, a MapProperty of ObjectProperty → StructProperty("LBBalancerIndexing"). That value is a native struct written as 12 raw bytes (three int32s), not the tagged property list the parser expects:

+1124  08                 zero_or_eight
+1125  00 00 00 00        no ModeType
+1129  01 00 00 00        1 entry
+1133  00 00 00 00        key level name = ""
+1137  57 00 00 00 ...    key path name  = ".../Desc_CompactedCoal_C"
+1228  ff ff ff ff ff ff ff ff 37 00 00 00     <- the value: 12 RAW bytes
+1240  0c 00 00 00 "mInputIndex\0"             <- next property, exactly at start+115

start + 115 lands precisely on the next property, so the map body is well formed — the value is simply opaque. parse_properties read those bytes as a property name/type pair: ff ff ff ff decoded as an empty UTF-16 string, then the next length came out of ff ff 37 00 = 0x0037FFFF = 3670015, which fails UTF-8 validation. (The two Output failures are the same bug with a different payload — 0a 00 00 00 ... reads as a plausible length 10, hence the different message.)

StructProperty and ArrayProperty already fall back to opaque bytes for unknown modded structs. The map-value path had no such fallback.

The fix

Rather than teach the parser one more shape, stop treating an unparsable body as fatal. That fixes this class of bug for every mod rather than this one struct.

The skip machinery already existed — all 44 scan.parse_object call sites do else { continue }. Only two return Err checks in build_all_json made it fatal. Failed objects are now collected by instanceName, carried on MapIndex (so the set survives the CBOR handoff to the lean worker), and reported on the payload as unreadableObjects: { count, samples }. The load status line says so; type paths and byte offsets go to the console.

Nothing is lost visually. collect_buildings is generic and header-only — it keeps any type path containing /Buildable/ or /Build_ and draws from position/rotation/instanceName, never parsing the body. All 159 balancers still render, under "Unknown", with correct labels and positions. Only their body-derived contents are missing.

Edits stay strictly checked. MapIndex::reject_new_parse_failures refuses an edit that makes a previously-parsable object stop parsing — a mis-computed splice damaging its neighbours still trips it. It is deliberately scoped to objects that existed before the edit: copy/paste splices bytes under a fresh instanceName, so duplicating an unreadable modded buildable legitimately produces a new unreadable object, and an earlier version of this check blocked that working operation.

Clearer edit errors. Editor ops parse their target eagerly, so editing an unreadable object reported the raw String decode failure at offset 24369724. That was unreachable before (the save did not load at all). All 14 op call sites reach an object through apply::fetch, so one wrap there now names the object and explains it can be viewed but not edited.

Verification

• The reported save loads; all 159 balancers render; status reads "106 objects could not be read (usually modded); shown on the map without contents".
• Four vanilla saves produce byte-identical payloads and indexes against main (up to 379 MB) — no regression, and no unreadableObjects key on a clean save.
• Full suite green (78 tests), including a new tests/unparsable_objects.rs: a clobbered body must not fail the build, must be reported, must still render as a building, and the edit gate must fire on exactly the newly-broken pre-existing objects.

Not included

The opaque-map fallback that would let these buildables show their real contents. They render and can be selected, but their inventories are missing and they cannot be edited. Worth a follow-up if modded map-value structs turn up more often.

🤖 Generated with Claude Code