jan/rrt
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Close remaining static atlas and export work

Browse source
This commit is contained in:
Jan Petykiewicz 2026-04-14 17:52:45 -07:00
commit 049ffa6bd8
13 changed files with 842 additions and 338 deletions
Download patch file Download diff file Expand all files Collapse all files

228
docs/control-loop-atlas/editor-breadth.md
View file

@ -18,7 +18,28 @@ The broader map-editor page owner is now bounded through
the paired overall growth selector whose effects later appear in the city-growth side of the
simulation. `map_editor_city_region_panel_construct` and
`map_editor_city_region_panel_handle_message` own the city-or-region editing lane with rename and
copy-industry-data flows. The adjacent economic tuning page is explicit now too:
copy-industry-data flows. That page is tighter on the save/load seam now too:
`map_editor_city_region_panel_format_selected_region_detail_stats_and_projected_building_rows`
`0x004cc340` is the selected-region detail formatter bound by the constructor, and it is now a
grounded live reader of the same persisted economic tuning band
`[world+0x0be2/+0x0be6/+0x0bea/+0x0bee]`. It formats one current building-count row from
`[region+0x242]`, formats the leading tuning lane through localized id `0x40d`, and then uses
`world_region_accumulate_structure_category_totals` `0x00422900` plus
`world_region_query_projected_structure_count_scalar_by_category` `0x004234e0` to build the
projected/live category rows `0x40e..0x414`. The neighboring callback
`map_editor_city_region_panel_store_selected_region_density_scalar_and_rebuild` `0x004cc930`
writes the selected region density scalar back into `[region+0x25a/+0x25e]` and reconstructs the
page, and the `.smp` restore owner `0x00446d40` now shows the same pair being rehydrated as one
shared density dword on newer bundles or one legacy bucket-to-density lookup on pre-`0x3f3`
bundles, so the `Cities/Regions` page now has one direct live write-side density lane and one
concrete restore-side bridge instead of only the older generic page note.
The broader handler `0x004ce380` is tighter in the same way now too: besides rename and source
chooser flows, it commits one direct callback value into `[region+0x272]`, forwards another
through `0x004204c0` on the selected region, supports two bulk profile-weight sweeps over the
live candidate pool through `0x004206b0` using `0.0` or `1.0`, and uses chooser result `0x3f2`
to re-enter `0x00420e00` for source-region profile cloning before rebuilding the page; the same
direct callback lane now also matches the `.smp` restore-side write into `[region+0x272]`.
The adjacent economic tuning page is explicit now too:
`map_editor_economic_cost_slider_panel_construct` `0x004cadf0` registers
`map_editor_economic_cost_slider_dispatch` `0x004ca980` on six visible slider controls
`0x5bcd..0x5bd7`, re-publishes the current values from
@ -33,6 +54,10 @@ The broader map-editor page owner is now bounded through
preview curve from leading lane `[world+0x0be2]` plus the stepped multiplier table
`[world+0x0be6/+0x0bea/+0x0bee/+0x0bf2/+0x0bf6]`, and republishes the six formatted numeric
rows through the neighboring dynamic-text controls `0x5bce/0x5bd0/0x5bd2/0x5bd4/0x5bd6/0x5bd8`.
The post-load consumer side is tighter now too: the same selected-year bringup later runs
`0x00433bd0`, `0x00435603`, and `0x00434130`, where `0x00433bd0` rebuilds one direct year-bucket
trio plus two dependent three-lane companion bands from the fixed year ladder, and `0x00434130`
reclamps shared year-gap scalar `[world+0x4ca2]` into the closed `1/3..1.0` band.
That closes the economic tuning page as one real save/load-facing editor family rather than only
a constructor plus one write-only slider dispatcher. The city-or-region copy side is tighter now too: the
handler first enters
@ -72,7 +97,11 @@ The broader map-editor page owner is now bounded through
concrete range and row callbacks behind list control `0xa7fa`, so the persisted 49-dword
scenario-rule band `[world+0x4a7f..+0x4b3f]` is no longer only constructor-shaped in the atlas.
The constructor `0x004cb2b0` binds those callbacks, counts enabled rows directly from that same
dword band, and keeps the trailing scalar `[world+0x4b43]` in the same page family.
dword band, and keeps the trailing scalar `[world+0x4b43]` in the same page family. The handler
is tighter now too: `0x004cb8e0` bulk-writes the full 49-dword rule array from `0xa7fb/0xa7fc`,
parses control `0xa7ff` back into trailing scalar `[world+0x4b43]`, and special-cases rule
ordinals `0x19` and `0x1a` through immediate follow-on calls to `0x00493150` and `0x00413620`
after direct row writes from callback band `0xabe0..0xafc7`.
`map_editor_territory_panel_construct` and
`map_editor_territory_panel_handle_message` own the territory rename and border-remap lane;
`map_editor_locomotive_availability_panel_construct` plus
@ -130,26 +159,35 @@ The broader map-editor page owner is now bounded through
the per-cargo runtime summary tables. That helper now reads more concretely too: it clears both
emitted cargo-id tables at `[candidate+0x79c]` and `[candidate+0x7a0]`, clears the per-cargo
float band at `[candidate+0xa1..+0xb8]`, and fills one local `0x35`-cargo status scratch from
the descriptor strip. Each subordinate row contributes status `1` when the cargo is only
referenced and status `2` when the row is currently year-active, with the helper keeping the
maximum status per remapped cargo id through `0x0062ba8c+0x9a`. It then allocates the two final
the descriptor strip. The year window is narrower than the earlier generic wording too: each
subordinate row contributes status `2` only while `start_year <= current_year < end_year`, using
live world year `[0x006cec78+0x0d]` or fallback year `0x709` when no world is present; rows
outside that active window still contribute status `1` as referenced cargo, and the helper keeps
the maximum status per remapped cargo id through `0x0062ba8c+0x9a`. It then allocates the two final
compact membership tables from the `status>=1` and `status>=2` sets with counts stored at
`[candidate+0x7a4]` and `[candidate+0x7a8]`. The same scan also makes the production-mode split
explicit on the runtime side: descriptor mode `0` uses the shared production cap at
`[candidate+0x2a]` divided by the descriptor amount, while nonzero mode bypasses that scaling
path and publishes the row amount directly. At that point the candidate import strip is
structurally closed in current local evidence: the local import and rebuild seam is no longer
where the loader reconstructs runtime descriptor or membership tables. The remaining semantic gap
is narrower instead: current local evidence shows no hidden decode stage for the supply-marker
token family at all. The editor slab preserves unmatched token strings verbatim, the constructor
only reflects selector ordinals for tokens that already exact-match visible live cargo names, and
the importer later writes the exact-matcher result ids straight into the live descriptor lanes,
defaulting failed matches to cargo id `0`. The reset side narrows that further too:
where the loader reconstructs runtime descriptor or membership tables. Current local evidence now
supports a stronger carry for the supply-marker token family too: there is no hidden decode stage
surfaced at all, so those lanes are best kept as opaque scenario-authored marker strings. The
editor slab preserves unmatched token strings verbatim, the constructor
only reflects selector ordinals for tokens that already exact-match visible live cargo names, the
handler writes selected cargo names back into those same token slots verbatim, and the importer
later writes the exact-matcher result ids straight into the live descriptor lanes, defaulting
failed matches to cargo id `0`. The reset side narrows that further too:
`0x00436d10` only zero-fills the recipe books and reseeds their `# %1` name lane, so those
marker-like token strings are not coming from the built-in reset path. So the open question is
now only what upstream source, if any, authored those marker-like token strings before exact
matching. The
immediate sibling
marker-like token strings are not coming from the built-in reset path. A fresh direct-hit scan
on the recipe-book root `0x0fe7` also did not surface any new live writer beyond the already
grounded reset, save/load, and editor-panel families. The one suspicious later hit neighborhood
around `0x00500c73/0x00500d3f` turns out not to be another recipe writer either: it is a shell
control-construction strip using localized ids `0x0fe6/0x0fe8/0x0fe9` as UI resource ids, not
`[world+0x0fe7]` accesses. Combined with the checked map/save pairs that preserve those raw
marker payloads byte-for-byte, that closes the load/save ownership question at the current
evidence level: inside the local binary the marker families are best treated as opaque
scenario-authored token payload, not as a hidden runtime decode stage waiting to be mapped. The immediate sibling
`structure_candidate_refresh_recipe_runtime_mode_flags_0x78c_0x790` `0x00411ce0`, which for
subtype byte `[candidate+0x32] == 2` scans the imported descriptor strip and derives two compact
post-import flags from mode `0` presence and whether every mode-`0` descriptor keeps at least
@ -165,14 +203,54 @@ The broader map-editor page owner is now bounded through
fixed name catalog at `0x0061dbc2/0x0061dc09` for non-subtype-`1` zero-availability candidates
with live ids `<= 0x6e` via localized string `0x0b53`, and only then re-enters the same
named-availability refresh at `0x00412c10` before returning. The broader scenario-state reset
and editor-writer side is explicit now too: the saved named-availability table is not only
startup-owned. `map_editor_industry_availability_panel_handle_message` `0x004cf430` has one
direct row-callback path for controls `0xa028..0xa40f` that forwards the clicked candidate name
plus one callback-supplied boolean into `0x00434f20`, and one bulk boolean sweep from the top
controls `0x9c43` and its sibling that walks the live candidate pool and forwards every
surviving page-visible candidate into that same upsert owner. So the scenario-side
availability override bit at `[entry+0x1e]` now has three grounded write families together:
startup preseed, stream-load refresh, and editor-side direct or bulk override. The package-save
side is explicit now too: in the editor-map branch of `0x00444dd0`, the shared prepass
`scenario_state_preseed_named_candidate_availability_overrides_from_editor_map_placed_structures`
`0x00436a70` walks qualifying placed structures, resolves their linked candidate/runtime owners,
and upserts boolean overrides from owner names immediately before the named-availability
collection is serialized.
The broader scenario-state reset
side is explicit now too: `0x00436d10` is the shared reset-and-rebuild owner beneath startup and
world-entry paths. It zeroes the late scenario-state bands, seeds the fixed year defaults and
chairman-slot rows, rebuilds the two named availability collections at `[state+0x66b2]` and
world-entry paths. It zeroes the late scenario-state bands, immediately reseeds setup-preview
validity byte `[state+0x66be] = 1`, seeds the fixed `Minimum Start Year` / `Default Start Year`
/ `Maximum Start Year` trio at `[state+0x66ca/+0x66d2/+0x66ce]`, the four startup dwords
`[state+0x6a68/+0x6a6c/+0x6a70/+0x6a74] = 1`, and the chairman-slot rows, including the first
slot's special occupied-seat byte `[state+0x69db]`, clears the queued-event and fast-forward
latches `[state+0x46c38/+0x46c3c/+0x66a2/+0x66a6/+0x66aa]`, rebuilds the two named availability
collections at `[state+0x66b2]` and
`[state+0x66b6]`, zero-fills the twelve recipe books at `[state+0x0fe7]`, then only reseeds
their per-book name lane from the fixed `# %1` format string at `0x005c9f78` through
`0x0051b700 -> 0x00518de0`, refreshes selected-year state through `0x00409e80`, `0x00433bd0`,
`0x00435603`, and the year-gap scalar helper `0x00434130`, and only then re-enters
`0x00435630`, `0x0041e970`, `0x00412bd0`, and `0x00436af0`. The startup side is tighter now too:
`0x0051b700 -> 0x00518de0`. The selected-year rebuild tail is tighter now too: in the
campaign/setup-but-not-sandbox lane it copies profile year word `[profile+0x77]` into scenario
default start year `[state+0x66d2]`, seeds Jan-1 tuple lanes `[state+0x05/+0x09]` through `0x0051d3f0`,
optionally decrements that chosen year through the shell/tutorial gates at
`[0x006cec74+0x68/+0x178]` and `[0x006cec78+0x4af7]`, and only then rebuilds the absolute
selected-year counter through `0x0051d390 -> 0x00409e80`, the selected-year bucket band through
`0x00433bd0`, the derived year-threshold band through `0x00435603`, and the year-gap scalar
helper `0x00434130`. The matched editor-side consumer is explicit too:
`map_editor_scenario_metadata_panel_refresh_controls` `0x004ca790` republishes that same reset
block through the `0x5b69..0x5b74` control band, with the start-year trio landing on
`0x5b6a/0x5b6c/0x5b6b`, campaign-scenario byte `[state+0x66de]` on checkbox `0x5b6e`, and the
inverse of metadata byte `[state+0x66f3]` on control `0x5b74`. Only after that chain does it
meet its write-side sibling: `map_editor_scenario_metadata_panel_handle_message` `0x004cb4a0`
commits the same control band back into live state by copying bounded text payloads into
`[state+0x672e]`, `[state+0x4f30]`, and `[state+0x5ae9]`, flipping `0x621f50`,
toggling `[state+0x66de]` and `[state+0x66f3]`, and parsing the three year edit fields through
`0x005a1ea5` before clamping each to `1829..2100` and enforcing
`minimum <= default <= maximum`.
Only after that chain does it
re-enter `0x00435630`, `0x0041e970`,
`0x00412bd0`, and `0x00436af0`, where the cached available-locomotive rating now reads as a
year-tiered baseline `110/200/300` plus the strongest surviving live locomotive rating filtered
by era-policy and named-availability gates, then normalized through the fixed `100/220` scale
pair and clamped into the final `50..100` cache band at `[world+0x4cbe]`. The startup side is tighter now too:
`0x00438890` does not jump straight into one selector-specific file-load branch. It first
re-enters `0x00436d10`, mirrors one shell-managed label list from `0x006d4020+0x429b0` into local
state, allocates the common runtime pools (`0x0062ba8c`, `0x0062b268`, `0x0062b2fc`,
@ -224,9 +302,11 @@ The broader map-editor page owner is now bounded through
`[this+0x178]`. There is still no post-resolution failure guard between the importer writes and
the summary-bank updates. So the strongest current read is narrower than a full cargo-id decode: if
the imported low-16 marker rows fail the exact matcher at `0x0041e9f0`, the resulting `0` ids
will still hit the first summary-bank bucket inside `0x00412650`, but the semantic meaning of
cargo id `0` itself remains ungrounded. So the remaining gap here is semantic only, not another
missing import or rebuild owner. The sibling helper
will still hit the first summary-bank bucket inside `0x00412650`, but the caller layer above
that bank now treats cargo id `0` as the nonstandard linked-site classification sentinel rather
than one ordinary cargo id. So the remaining gap here is only whether any opaque saved marker
words encode real cargo ids before they reach that matcher, not another missing import or
rebuild owner. The sibling helper
`structure_candidate_supports_or_references_cargo_id`
`0x004129d0` then uses those same banks plus the cached cargo-membership arrays to answer whether
a live candidate materially references a cargo at all. One compare step tighter, the raw line
@ -243,8 +323,11 @@ The broader map-editor page owner is now bounded through
`0x00170000`, `0x00150000`, `0x00004040`, and `0x00004000`, demanded tokens include
`0x00010000`, `0x68430000`, and `0x6c410000`, and the later `line02` mode words stabilize at
`0x00070000` then `0x00010000`. So the loader can now safely treat these raw line lanes as
preserved scenario payload with family-specific signatures, even though the exact cargo-id and
mode-enum semantics still need separate grounding. One inference is tighter now too: when those
preserved scenario payload with family-specific signatures. The mode family itself is now
grounded at the player-facing layer: the editor page and importer split line up on `Disabled`,
`Demand Only`, `Supply Only`, and `Production Demand->Supply`, with mode `0` skipped on import,
mode `1` entering the demand-only branch, mode `3` entering the dual production branch, and the
remaining nonzero modes taking the supply-side branch. One inference is tighter now too: when those
demanded-token words are zero in the low 16 bits and printable in the high 16 bits, the byte
order reads as short two-letter stems such as `Gr`, `Co`, `Li`, `Mi`, `Ch`, and `Al`, which fit
the current scenario cargo-name families `Grain`, `Corn`, `Livestock`, `Milk`, `Cheese`, and
@ -300,9 +383,10 @@ The broader map-editor page owner is now bounded through
zero-mode-cap-scaled-subrow lanes by that count, and then writes the finished quartet into
candidate dwords `[candidate+0x8e/+0x92/+0x96/+0x9a]` while stamping
`[candidate+0x8a]` from current world field `[0x006cec78+0x15]`. So the current strongest read
remains structural rather than semantic: unresolved marker rows can still propagate through the
first bank bucket, but the first place that meaning matters is a normal positivity-gated
cargo-channel consumer, not a dedicated null-cargo branch.
is no longer an unresolved null-cargo semantic question inside the load bridge: unresolved
marker rows can still propagate through the first bank bucket, but the first place that meaning
matters is a normal positivity-gated cargo-channel consumer rather than a dedicated null-cargo
branch.
The caller side is narrower than before too. The steady-state site bitset owner
`placed_structure_rebuild_candidate_cargo_service_bitsets` `0x0042c690` starts its inner cargo
loop at id `1` and only walks upward through the current live cargo count, so it never
@ -317,8 +401,8 @@ The broader map-editor page owner is now bounded through
tighter than before too: it resolves the linked peer's backing candidate through the peer site id
at `[peer+0x04]`, reads candidate class byte `[candidate+0x8c]`, and returns true only for the
first three class values `0/1/2` while rejecting `3/4` and anything above `4`. So current local
callers treat cargo id `0` as a nonstandard request bound to one linked-site reachability or
classification side path, not one ordinary cargo lane they routinely probe.
callers treat cargo id `0` as a nonstandard linked-site-classification sentinel, not one
ordinary cargo lane they routinely probe.
The vtable-`+0x70` latch itself is bounded a bit better now too. It still lacks a direct field
decode, but every local callsite we checked around `0x0040d230`, `0x0040dba0`, `0x0040dbf0`, and
`0x0040f670` uses that slot only as the precondition for touching `[site+0x2a8]` and the
@ -347,10 +431,10 @@ The broader map-editor page owner is now bounded through
only by that pair. Local `objdump` shows tiny direct setters at `0x0040cbc0` and `0x0040cbd0`
plus a raw getter at `0x0040cbf0`, so the `0x0040dba0/0x0040dbf0` pair is writing one shared
placed-structure state byte rather than inventing a route-entry-only scratch lane. One caution
is tighter now too: there are later mode-gated reads at other addresses that also touch a
`+0x42` byte on their own object layouts, but current local evidence does not yet prove those are
the same placed-structure owner family, so the safest current note keeps only the immediate
`0x0040cbc0/0x0040cbd0/0x0040cbf0/0x0040dba0/0x0040dbf0` cluster grounded together.
is tighter now too: later mode-gated reads at other addresses also touch a `+0x42` byte on their
own object layouts, so the safest current note keeps only the immediate
`0x0040cbc0/0x0040cbd0/0x0040cbf0/0x0040dba0/0x0040dbf0` cluster grouped together and does not
reuse those later byte reads as same-family evidence.
The vtable side sharpens that split too. A local `.rdata` scan shows `0x0040dba0` and
`0x0040dbf0` each appearing exactly once, together with `0x0040cbf0`, in one method table rooted
at `0x005c8c50`; the constructor chain is tighter now too, because `0x0040c950` installs that
@ -551,7 +635,7 @@ The broader map-editor page owner is now bounded through
`0x00441f70` and
`shell_map_bundle_write_global_staging_buffer_to_companion_image_file_and_return_path`
`0x004420f0` are the paired `_A.tga` / `_A.jpg` import and export helpers around the same
tagged selector strip at `0x00441ec0`. Both derive an extensionless stem through
tagged stage-dword plus fixed-preview strip at `0x00441ec0`. Both derive an extensionless stem through
`support_copy_string_stem_before_first_dot` `0x0051dde0`, choose the `_A.tga` versus `_A.jpg`
suffix by selector byte `[record+0x09]`, and then shuttle the file bytes through the shared
staging descriptor rooted at `0x0062bed4/0x0062bed8`. That keeps the family grounded on the same
@ -559,11 +643,32 @@ The broader map-editor page owner is now bounded through
`world_presentation_rebuild_four_overlay_surface_slots_from_source_or_fallback` `0x00535430`,
instead of leaving it as an isolated save-side file copier. The neighboring exporter
`shell_export_live_setup_preview_payload_record_and_normalize_pixel_block_0x100x0x100`
`0x00442ba0` is bounded now too: it copies the live setup payload from `[this+0x66be]`,
patches world dimensions and three shell bytes into offsets `+0x01..+0x0b`, and then
normalizes the embedded `0x100 x 0x100` pixel block at `+0x03c2` through `0x0047a120`
before the save-side callers forward that same record into `0x00441ec0` or the tagged
slot-table serializer at `0x00446312`. The broader sibling
`0x00442ba0` is bounded now too: it copies one `0x403c2`-byte live setup-preview payload record
from `[this+0x66be]`, forces validity byte `+0x00 = 1`, patches world dimensions and three shell
bytes into offsets `+0x01..+0x0b`, and then normalizes the embedded `0x100 x 0x100` pixel block
at `+0x03c2` through `0x0047a120` before the save-side callers branch in two different ways. The
package-save path at `0x00444f42` calls `0x00442ba0` and then immediately enters `0x00441ec0`
at `0x00444f47`, while the `.smp` serializer branch at `0x00446312` calls `0x00442ba0` first and
then emits `0x2ee0`, writes the full `0x403c2` payload through `0x00531030`, and closes `0x2ee1`
directly without re-entering `0x00441ec0`. The `0x00441ec0` strip is tighter now too: it
snapshots the shared leading dword seeded from `0x00620e94`, then mirrors one `dword + 0x2ee0 +
0x03c2 + 0x2ee1` strip through its staged-object or companion-file transport branches, and does
not itself choose the companion-image selector byte. The same negative boundary is explicit now too:
current local restore-side evidence still does not show either `0x00441ec0` or the later `.smp`
loader `0x00446d40` writing that restored leading dword back into `0x00620e94`, so the sidecar
format is carrying more framing than the grounded restore owners currently republish into live
state. The copied shell-byte trio is
tighter now too: current local disassembly grounds payload bytes `+0x09/+0x0a` as direct mirrors
of shell-controlled sidecar dwords `[0x006d4024+0x11471a/+0x11471e]`, while `+0x0b` is the low
byte of shared dword `0x0062bec4` later seeded by the package-save coordinator from the sibling
selector pair `[0x006d4024+0x11472a/+0x11472e]`; the display-runtime defaults path around
`0x0051ee48..0x0051ee85` initializes those same four dwords together, and the broader
`shell_settings_window_handle_message_dispatch_and_persist_display_runtime_sidecar_family`
`0x00464c80` later owns the direct toggle strip for controls `0xe101..0xe104`, including the
grounded implication rules `!0x11471e -> clear 0x11472a` and `(0x11472a || 0x11472e) -> set 0x11471e`.
Payload bytes `+0x0a/+0x0b` are therefore the same
companion-image and companion-payload sidecar gates later read from `[world+0x66c8/+0x66c9]` in
the package-save tail. The broader sibling
`shell_build_temp_surface_from_payload_preview_pixels_and_query_named_resource_field_0x46`
`0x00442740` is bounded now too: it copies the embedded preview pixels at `[record+0x03c2]`
into a temporary `0x40000`-byte RGBA buffer, constructs one temporary `0xec`-byte surface-like
@ -573,21 +678,23 @@ The broader map-editor page owner is now bounded through
`0x0053b080`. That keeps the short save-side branch at `0x00445925` grounded as a one-shot
preview-surface query helper rather than leaving another anonymous image-copy leaf between the
tagged export path and the progress notice strip. The broader sibling
`shell_map_bundle_rewrite_companion_payload_file_via_tmp_path_and_progress_callback`
`0x004427c0` is now bounded as the temporary-path owner above that same tag strip: it derives
`%1.tmp` from the source path, installs progress callback `0x00441e20` in `0x00d93988`,
`shell_map_bundle_rewrite_companion_payload_file_via_tmp_extension_path_and_progress_callback`
`0x004427c0` is now bounded as the `.tmp`-extension owner above that same tag strip: it strips
the caller extension, appends `.tmp`, installs progress callback `0x00441e20` in `0x00d93988`,
rewrites the middle payload band rooted at `+0x03ce` through `0x00553000`, writes the result
back out through `0x005a276f`, updates payload dword `[record+0x18]`, and only then re-enters
`0x00441ec0`.
The sibling `shell_map_bundle_rewrite_companion_payload_file_from_record_offsets_and_sync_tags`
The sibling
`shell_map_bundle_rewrite_companion_payload_file_from_path_stored_byte_offsets_and_sync_tags`
`0x00442900` is bounded now too: it takes the live payload record in `EAX`, reads the full
companion file named by the caller path, installs the same progress callback, rewrites the
middle payload through `0x00553000` using stored offsets `[record+0x18/+0x1c]`, and then writes
the output back in four spans: the leading `0x03ce` bytes, the transformed middle payload, the
untouched interval `[record+0x18 .. record+0x1c)`, and the remaining tail. It then stores the
caller path back into `[record+0x18]` and re-enters `0x00441ec0`. That closes the offset-driven
save-side sibling reached from `0x004459dd` after `0x00441f70`, so the companion-payload strip
is no longer split between one named temp-path owner and one anonymous offset-band rewrite body.
caller path back into `[record+0x18]` and re-enters `0x00441ec0`. That closes the path-plus-
stored-offset save-side sibling reached from `0x004459dd` after `0x00441f70`, so the
companion-payload strip is no longer split between one named temp-path owner and one anonymous
offset-band rewrite body.
The underlying temporary-surface seam beneath those save-side helpers is bounded now too.
`surface_owner_allocate_first_free_row_slot_0xa0_and_seed_dimensions_and_type` `0x00541b10`
scans the eight-entry row band `[this+0xa0..+0xbc]`, allocates one `0x32`-byte row, seeds width,
@ -692,15 +799,19 @@ The broader map-editor page owner is now bounded through
`0x00444b50` with the loaded scenario title, and it dispatches on many fixed `.rdata` names
including `Go West!`, `Germany`, `France`, `State of Germany`, `New Beginnings`, `Dutchlantis`,
`Britain`, `New Zealand`, `South East Australia`, `Tex-Mex`, `Germantown`, `The American`,
`Central Pacific`, and `Orient Express`, with several branches further gated by setup payload
byte `[this+0x66de]`. The matched branches then perform targeted live-world edits rather than a
generic title-side publish: they patch object-state dwords and bytes inside collections rooted at
`0x0062be18`, `0x0062bae0`, and `0x006ada80`, adjust selected float and scalar fields, copy
paired ten-dword record blocks when specific name/class pairs match, flip secondary-raster bits
through table `0x005ee508..0x005ee5cc`, retune a later collection at `0x0062b268`, and inject
scenario-specific text lines into the shell-owned band `[this+0x4f30]` through repeated
`0x0051e5d0`. That finally makes the broad post-load scenario-fixup seam explicit instead of
leaving it as an unbounded string-switch body beneath world entry.
`Central Pacific`, and `Orient Express`, with several branches further gated by campaign-scenario
byte `[this+0x66de]`. The matched branches now have a few concrete anchors too instead of reading
as one anonymous title-side publish. The non-campaign `Go West!` branch retags world-object row
`7` named `Open Aus` by promoting byte `[obj+0x7f9]` from `1` to `2` when its nested opcode-`0x1b`
payload is still in the expected starter state; the campaign-gated `Go West!`/`Germany`/`Orient Express`
side nudges selected city float pairs `[city+0x25a/+0x25e]` upward when they remain below fixed
thresholds; and the `Central Pacific` branch injects repeated localized `Company Track Miles`
text lines into shell band `[this+0x4f30]` through `0x0051e5d0`. Beyond those grounded examples,
the owner also patches object-state dwords and bytes inside collections rooted at `0x0062be18`,
`0x0062bae0`, and `0x006ada80`, copies paired ten-dword record blocks when specific name/class
pairs match, flips secondary-raster bits through table `0x005ee508..0x005ee5cc`, and retunes one
later collection at `0x0062b268`. That finally makes the broad post-load scenario-fixup seam
explicit instead of leaving it as an unbounded string-switch body beneath world entry.
One neighboring status helper is bounded now too:
`shell_publish_progress_sample_notice_from_byte_delta_and_elapsed_ticks` `0x00442660` is the
shared byte-delta and elapsed-time notice builder used by both the bundle-service strip and the
@ -1095,5 +1206,6 @@ The broader map-editor page owner is now bounded through
`0x004d3080` is the actual `General Validation` constructor over
`map_editor_general_validation_report`, and the same page table also now grounds `Stats - Cargo`,
`Stats - City/Region`, `Stats - City Count`, `Event Variable Values`, and the neighboring
event-validation page. The remaining open editor edge is therefore mostly the deeper gameplay
meaning of those site-side service scores and flag bits, not page ownership.
event-validation page. Those residual site-side scores and flag bits can now be carried
conservatively as event-validation gameplay metric bands rather than as another editor ownership
seam.