Bound packed-state trigger-kind omission

artifacts/exports/rt3-1.06/function-map.csv

@@ -284,7 +284,7 @@ address,size,name,subsystem,calling_convention,prototype_status,source_tool,conf
 0x00468300,235,placed_structure_route_link_rebuild_route_style_grid_counters_and_endpoint_state,map,thiscall,inferred,objdump + caller inspection + world-grid correlation + collection-iteration inspection,3,"Higher-level rebuild pass above the route-link family that resets the route-style world-grid counters and then recomputes live endpoint state across `0x006ada90`. The helper first reads three candidate-class ids from the structure-candidate side table at `0x0062ba8c+0x88/+0x8a/+0x8c`, walks the active world-grid tables rooted at `[0x0062c120+0x2129]`, and clears the aligned per-cell dword lanes at offset `+0x103` for those three classes. It then iterates every live route-link record in `0x006ada90`, clears state bit `0x2` in each record's flag byte at `+0x12`, and re-enters `placed_structure_route_link_recompute_endpoint_pair_state` `0x00467c30`. Current grounded callers include the recurring simulation-maintenance branch at `0x0040a575`, the world bring-up side near `0x00444b2f`, and one later world-side update path at `0x00481157`, which makes this the clearest current owner of the full-family route-style counter-and-state rebuild rather than just another collection walk.","objdump + caller inspection + world-grid correlation + collection-iteration inspection + route-style-class correlation"
 0x0041e2b0,589,structure_candidate_rebuild_local_service_metrics,map,thiscall,inferred,objdump + caller xrefs + callsite inspection,3,"Setup-side local-metrics rebuild for one live structure candidate after it has passed `structure_candidate_is_enabled_for_current_year` at `0x0041e220`. The helper clears the metric bands at `[this+0x6a]`, `[+0x6e]`, `[+0x72]`, `[+0x76]`, and `[+0x7a]`, then samples repeated world-grid slices off the active world root at `0x0062c120` through `0x0042c960` and the per-cell tables rooted at `[world+0x2129]`. It accumulates one broad local magnitude at `[this+0x6a]`, folds two optional positive channels into `[this+0x6e]` and `[this+0x72]`, and finally normalizes and scales the trailing summary pair `[this+0x76]` and `[this+0x7a]` with fixed constants. Current grounded caller is `structure_candidate_collection_run_post_load_local_service_setup_phase` at `0x0041ea50`, so this still looks like a setup-time local service or demand scorer rather than the recurring owner of the whole cargo-economy lane, but it is now one clear downstream consumer of the same `[candidate+0x56]` live-availability gate.","objdump + caller xrefs + callsite inspection + world-grid correlation"
 0x0042da90,129,scenario_event_prepare_runtime_record_text_bands_for_packed_state_save,scenario,thiscall,inferred,objdump + local disassembly + caller correlation,3,"Small pre-save sweep over one live runtime event record immediately beneath the `.smp` event-collection serializer `0x00433060`. The helper re-enters `0x0042d820` six times with save-side flag `1` over the fixed text-band families rooted at `[record+0x0e0]`, `[+0x401]`, `[+0x4ca]`, `[+0x593]`, `[+0x65c]`, and `[+0x725]`, using size `0x320` for the first band and `0xc8` for the remaining five. Current grounded caller is the first event-collection sweep inside `0x00433060`, so this is the safest current read for the text-band preparation pass that runs before the packed runtime-record stream is emitted rather than for a standalone serializer.","objdump + local disassembly + caller correlation + fixed-text-band correlation"
-0x0042db20,1040,scenario_event_refresh_runtime_record_from_packed_state,scenario,thiscall,inferred,objdump + caller inspection + local disassembly + shell-event-window correlation,2,"Heavy per-event runtime materializer beneath the live event collection at `0x0062be18`. The helper reads one packed event definition from the caller-supplied state or stream object, conditionally clears and repopulates several fixed text bands on the destination event record at offsets such as `+0x0e0`, `+0x401`, `+0x4ca`, `+0x593`, `+0x65c`, and `+0x725`, then rebuilds two event-runtime row families from caller-supplied counts and packed row payloads. Current shell-side xrefs now tighten that split. The first family allocates `0x1e`-byte rows, fills scalar and byte fields from the packed source, conditionally extends the row on later-format branches, remaps bounded id ranges through the live structure-candidate collection `0x0062ba8c`, and links the resulting rows through one standalone event-side list anchor; the adjacent helper cluster `0x0042df30/0x0042df70/0x0042dfb0/0x0042dff0` is only consumed by `EventConditions.win`, so this first family now reads as the runtime condition-row list. The second family repeats the same materialization pattern with `0x28`-byte rows across four grouped slots on the destination event record, applying version-gated field extension and bounded remap logic against the locomotive collection `0x006ada84`, the live structure-candidate collection `0x0062ba8c`, and the global candidate pool `0x0062b268` before linking each rebuilt row into one of four grouped list anchors; the generic deep-copy helper `0x0042e050` now clones those same grouped lists during event duplication, so this second family still reads as the grouped event-effect row side rather than another condition list. Current grounded caller is the collection-wide wrapper `0x00433130`, so this is now the safest current read for one live event's runtime-record refresh from packed scenario-state data rather than a generic collection helper.","objdump + caller inspection + local disassembly + event-record materialization correlation + candidate-and-locomotive-remap correlation + shell-event-window correlation"
+0x0042db20,1040,scenario_event_refresh_runtime_record_from_packed_state,scenario,thiscall,inferred,objdump + caller inspection + local disassembly + shell-event-window correlation,2,"Heavy per-event runtime materializer beneath the live event collection at `0x0062be18`. The helper reads one packed event definition from the caller-supplied state or stream object, conditionally clears and repopulates several fixed text bands on the destination event record at offsets such as `+0x0e0`, `+0x401`, `+0x4ca`, `+0x593`, `+0x65c`, and `+0x725`, then rebuilds two event-runtime row families from caller-supplied counts and packed row payloads. The negative boundary is tighter now too: direct disassembly does not show this helper restoring the event metadata band `+0x7ee..+0x80e`, so bytes like `[event+0x7ef]`, `[event+0x7f4]`, and `[event+0x7f9/+0x7fa]` do not come from the packed-state path here. Current shell-side xrefs now tighten the rebuilt row split. The first family allocates `0x1e`-byte rows, fills scalar and byte fields from the packed source, conditionally extends the row on later-format branches, remaps bounded id ranges through the live structure-candidate collection `0x0062ba8c`, and links the resulting rows through one standalone event-side list anchor; the adjacent helper cluster `0x0042df30/0x0042df70/0x0042dfb0/0x0042dff0` is only consumed by `EventConditions.win`, so this first family now reads as the runtime condition-row list. The second family repeats the same materialization pattern with `0x28`-byte rows across four grouped slots on the destination event record, applying version-gated field extension and bounded remap logic against the locomotive collection `0x006ada84`, the live structure-candidate collection `0x0062ba8c`, and the global candidate pool `0x0062b268` before linking each rebuilt row into one of four grouped list anchors; the generic deep-copy helper `0x0042e050` now clones those same grouped lists and the omitted metadata band during event duplication, so this second family still reads as the grouped event-effect row side rather than another condition list. Current grounded caller is the collection-wide wrapper `0x00433130`, so this is now the safest current read for one live event's runtime-record refresh from packed scenario-state data rather than a generic collection helper.","objdump + caller inspection + local disassembly + event-record materialization correlation + candidate-and-locomotive-remap correlation + metadata-band omission correlation + shell-event-window correlation"
 0x0042d700,59,scenario_event_query_standalone_condition_row_list_class_and_modifier_flags,scenario,thiscall,inferred,objdump + EventConditions.win refresh correlation + local disassembly,2,"Aggregates the class and modifier bits implied by one live event's standalone `0x1e`-row condition list. The helper first short-circuits to literal `0x7f` when event byte `[event+0x82b]` is set, then otherwise walks the list rooted at `[event+0x00]`, OR-ing the static row-class byte from `0x005f3e04 + id*0x81` for ordinary nonnegative row ids and using the negative-id fallback branch only to preserve special marker value `0x7f`. Current grounded callers are the condition-window summary refreshes `0x004d9970` and the broader control refresh `0x004da0f0`, so this is the safest current read for the standalone condition-list class or modifier aggregate rather than a generic linked-list scan.","objdump + EventConditions.win refresh correlation + local disassembly + condition-row-class-table correlation"
 0x0042d740,87,scenario_event_query_grouped_effect_row_list_type_flags,scenario,thiscall,inferred,objdump + EventConditions.win refresh correlation + local disassembly,2,"Aggregates one grouped effect-row type bitfield for a live event. The caller supplies the grouped list ordinal on the stack, and the helper walks the selected grouped anchor at `[event + group*4 + 0x04]`, OR-ing one descriptor byte from `0x006103fd + opcode*0x6e` across the linked `0x28`-row family. One caller-controlled boolean also enables a narrower normalization path that remaps a small special opcode subset to shared bit `0x08` before the OR step. Current grounded callers are the conditions-window refresh family `0x004d9d10` and `0x004da0f0`, plus one world-side branch at `0x00431120`, so this is the safest current read for grouped effect-row type flags rather than a standalone condition helper.","objdump + EventConditions.win refresh correlation + local disassembly + grouped-effect-descriptor correlation"
 0x0042df30,63,scenario_event_condition_row_list_has_class_bit0_or_flag7f9_fallback,scenario,thiscall,inferred,objdump + EventConditions.win refresh correlation + static-bit-table inspection,2,"Tiny predicate over the standalone `0x1e`-row event-condition list rebuilt by `scenario_event_refresh_runtime_record_from_packed_state` `0x0042db20`. The helper walks the linked list rooted at the caller-supplied event record, tests each nonnegative row id against class-bit `0x01` in the static per-condition table at `0x005f3e04 + id*0x81`, and returns true on the first match. Rows with id `-1` instead fall back to event-record byte `[event+0x7f9]`. Current grounded callers are the `EventConditions.win` refresh path at `0x004da19a` and `0x004da23c`, so this now reads as the class-bit-0 condition-summary gate rather than a generic list scan.","objdump + EventConditions.win refresh correlation + static-bit-table inspection + fallback-flag correlation"
@@ -362,7 +362,7 @@ address,size,name,subsystem,calling_convention,prototype_status,source_tool,conf
 0x00429b90,92,company_collection_serialize_tagged_header_counts_and_save_live_records_into_bundle,simulation,thiscall,inferred,objdump + package-save correlation + local disassembly + tag correlation,3,"Package-save sibling for the live company collection `0x0062be10`. The helper opens tagged sections `0x61a9/0x61aa/0x61ab` through repeated `0x00531340` calls, serializes the indexed-collection header through `0x00517d90`, and then walks every live company entry dispatching each record through the current no-op payload callback `0x00424000` before closing the final tag. Current grounded caller is the package-save path that persists the live runtime collections beside the other world roots.","objdump + package-save correlation + local disassembly + tag correlation + per-entry-save correlation"
 0x00430270,225,world_try_place_random_structure_batch_from_compact_record,map,cdecl,inferred,objdump + local disassembly + caller correlation,3,"Shared world-side retry loop that tries to place multiple structures from one compact spawn record. The caller supplies one small record whose fields now read most safely as a structure or profile token at `+0x00`, requested placement count at `+0x11`, center coordinates at `+0x12/+0x14`, and placement radius or extent at `+0x16`. The helper translates the token through the static table at `0x0061039c` into the live structure-profile collection `0x0062b268`, increments the region-manager reentrancy counter at `[0x0062bae0+0x88]`, and then runs up to `200` randomized attempts while placements remain. Each attempt samples a candidate coordinate inside the requested radius, rejects points outside the live world bounds at `[0x0062c120+0x2155/+0x2159]`, resolves the owning region through `0x0044a800` and `0x0062bae0`, adapts the candidate through `0x00412880`, and finally re-enters `world_region_validate_and_commit_candidate_placement` `0x00422a70`. Successful placements decrement the remaining batch count and reset the local retry counter. Current grounded caller is the world-side dispatch branch at `0x00431b43`, where only compact record classes in the `0x1f7..0x265` table range enter this batch placer. This is therefore the strongest current read for the world-side randomized structure-batch placement loop rather than a region-worker-private helper.","objdump + local disassembly + caller correlation + placement-batch correlation"
 0x00430b50,624,scenario_runtime_effect_record_build_followon_effect_from_compact_record_and_targets,scenario,thiscall,inferred,objdump + local disassembly + caller correlation,3,"Builds one runtime-effect record in the live scenario event collection from a compact source record plus the caller's currently resolved targets. The helper first allocates a new runtime-effect entry through `scenario_event_collection_allocate_runtime_effect_record_from_compact_payload` `0x00432ea0`, then seeds several per-record control bytes and target selectors in the new object, including mode byte `[record+0x7ef]`, optional gating bytes `[record+0x7f4/+0x7f9/+0x7fa]`, a primary selector at `[record+0x7f0]`, and optional comparison ids at `[record+0x82c/+0x830]`. Current grounded callers are the compact runtime-effect dispatcher `0x00431b20`, where fallback branches synthesize follow-on runtime effects from one compact linked record, and the shell-side branch at `0x004d60fd`, where the same builder is reached with a caller-owned output slot. This is therefore the current safest read for the runtime-effect follow-on record builder rather than a generic collection insert wrapper.","objdump + local disassembly + caller correlation + runtime-effect-builder correlation"
-0x00430d70,990,scenario_event_serialize_runtime_record_into_packed_state,scenario,thiscall,inferred,objdump + local disassembly + caller correlation,3,"Per-record save-side companion to `scenario_event_refresh_runtime_record_from_packed_state` `0x0042db20` beneath the `.smp` event-collection serializer `0x00433060`. The helper first re-enters `0x0042d820` six times with clear-side flag `0` over the same fixed text bands rooted at `[record+0x0e0]`, `[+0x401]`, `[+0x4ca]`, `[+0x593]`, `[+0x65c]`, and `[+0x725]`, then counts the standalone linked runtime-condition row chain at `[record+0x00]` and the four grouped runtime-effect row chains rooted at `[record+0x04/+0x08/+0x0c/+0x10]`. It writes per-family version marker `0x526f`, serializes each `0x1e` condition row with its scalar and byte fields plus the optional resolved candidate-name side string for bounded candidate-id ranges, emits grouped-row marker `0x4eb8` plus the four per-slot counts, and then serializes each `0x28` grouped row with the same version-gated field extension seen on restore, including the optional linked locomotive-name side string for bounded locomotive-id ranges before the later grouped remap and write-side branches continue. Current grounded caller is `scenario_event_collection_serialize_runtime_records_into_packed_state` `0x00433060`, so this is the safest current read for one live event's packed-state serializer rather than a broader collection walk.","objdump + local disassembly + caller correlation + event-record-save correlation + condition-row-and-effect-row correlation"
+0x00430d70,990,scenario_event_serialize_runtime_record_into_packed_state,scenario,thiscall,inferred,objdump + local disassembly + caller correlation,3,"Per-record save-side companion to `scenario_event_refresh_runtime_record_from_packed_state` `0x0042db20` beneath the `.smp` event-collection serializer `0x00433060`. The helper first re-enters `0x0042d820` six times with clear-side flag `0` over the same fixed text bands rooted at `[record+0x0e0]`, `[+0x401]`, `[+0x4ca]`, `[+0x593]`, `[+0x65c]`, and `[+0x725]`, then counts the standalone linked runtime-condition row chain at `[record+0x00]` and the four grouped runtime-effect row chains rooted at `[record+0x04/+0x08/+0x0c/+0x10]`. The negative boundary matches restore here too: direct disassembly does not show this helper serializing the event metadata band `+0x7ee..+0x80e`, so bytes like `[record+0x7ef]` are omitted from the packed-state stream. It writes per-family version marker `0x526f`, serializes each `0x1e` condition row with its scalar and byte fields plus the optional resolved candidate-name side string for bounded candidate-id ranges, emits grouped-row marker `0x4eb8` plus the four per-slot counts, and then serializes each `0x28` grouped row with the same version-gated field extension seen on restore, including the optional linked locomotive-name side string for bounded locomotive-id ranges before the later grouped remap and write-side branches continue. Current grounded caller is `scenario_event_collection_serialize_runtime_records_into_packed_state` `0x00433060`, so this is the safest current read for one live event's packed-state serializer rather than a broader collection walk.","objdump + local disassembly + caller correlation + event-record-save correlation + metadata-band omission correlation + condition-row-and-effect-row correlation"
 0x00431b20,399,world_apply_compact_runtime_effect_record_to_resolved_targets,map,thiscall,inferred,objdump + local disassembly + caller correlation,3,"Dispatches one linked compact runtime-effect record against the caller-resolved target context. The record token at `[*record+0x00]` is translated through the static table at `0x0061039c`; when the translated class lies in the `0x1f7..0x265` range the helper immediately re-enters `world_try_place_random_structure_batch_from_compact_record` `0x00430270`. Otherwise it jumps through the local class table at `0x004320b4/0x004320fc` into a mixed effect family that now includes: shell-state modifier branches over `0x006cec78`, signed scalar adjustments on resolved company/profile/territory targets through the `0x004d6611/0x004d6617` numeric readers, territory-access writes through `company_set_territory_access_rights_byte` `0x00424030`, selected-profile updates through `0x00434890/0x004348c0`, and several collection-side erase or follow-on branches. Current grounded caller is the outer loop at `0x00432317`, which walks linked compact records via `[record+0x24]` and supplies optional resolved company, chairman-profile, and adjacent owner context before each dispatch. This is therefore the current safest read for the wider compact runtime-effect dispatcher above the separate world-side structure-batch placement branch rather than as a placement-only helper.","objdump + local disassembly + caller correlation + effect-dispatch correlation"
 0x004323a0,842,scenario_runtime_effect_record_service_and_dispatch_linked_compact_effects,scenario,thiscall,inferred,objdump + local disassembly + caller correlation,3,"Per-record service pass over one live runtime-effect record in the scenario event collection. The helper first enforces several activation gates over the record's local control bytes and shell-side preview state, including one one-shot latch at `[this+0x81f]`, mode byte `[this+0x7ef]`, optional preview-policy byte `[this+0x7f4]`, and shell-side state at `0x006cec78/0x006cec74`. Once active it formats the optional status line through shell news helper `0x004554e0`, derives a target-availability bitmask through `0x0042d700`, resolves optional company/chairman/territory target pools, and then walks the linked compact effect chain rooted at `[this+0x00]`. Each linked record is dispatched through `world_apply_compact_runtime_effect_record_to_resolved_targets` `0x00431b20`, while fallback branches synthesize follow-on runtime-effect records through `scenario_runtime_effect_record_build_followon_effect_from_compact_record_and_targets` `0x00430b50`. When any effect fires it may refresh company share-price caches through `company_compute_public_support_adjusted_share_price_scalar` `0x00424fd0`, and records with nonzero `[this+0x7f5]` set the one-shot latch `[this+0x81f]`. Current grounded caller is the collection-wide service loop `scenario_event_collection_service_runtime_effect_records_for_trigger_kind` `0x00432f40`. This is therefore the current safest read for the runtime-effect record service and linked-effect dispatcher rather than a low-level target iterator.","objdump + local disassembly + caller correlation + runtime-effect-service correlation"
 0x00433060,198,scenario_event_collection_serialize_runtime_records_into_packed_state,scenario,thiscall,inferred,objdump + local disassembly + caller correlation,3,"Collection-wide save-side companion to `scenario_event_collection_refresh_runtime_records_from_packed_state` `0x00433130` for the live event collection at `0x0062be18`. The helper opens chunk `0x4e99`, writes fixed version dword `0x3e9`, walks every live event record in the collection through `indexed_collection_slot_count` `0x00517cf0`, `indexed_collection_get_nth_live_entry_id` `0x00518380`, and `indexed_collection_resolve_live_entry_by_id` `0x00518140`, and first re-enters `scenario_event_prepare_runtime_record_text_bands_for_packed_state_save` `0x0042da90` on each record. It then uses `0x00517d90` to emit the collection-side packed metadata, opens chunk `0x4e9a`, walks the same live records again through the same indexed-collection helpers, and re-enters `scenario_event_serialize_runtime_record_into_packed_state` `0x00430d70` on each one before closing with chunk `0x4e9b`. Current grounded caller is the `.smp` serializer `world_runtime_serialize_smp_bundle` `0x00446240`, so this is the safest current read for the event-side packed-state save owner rather than an anonymous collection walk.","objdump + local disassembly + caller correlation + event-collection-save correlation"

artifacts/exports/rt3-1.06/runtime-effect-kind8-late-bringup-note.md

@@ -95,6 +95,12 @@ The ordinary reload strip is bounded in the same negative way now:
   - clears collection flag `[this+0x88] = 0` before returning
 - that reload path does not pass any trigger-kind argument analogous to the later
   `0x00432f40(kind)` service
+- and the per-record helper `0x0042db20` is narrower than a full metadata restore:
+  - it conditionally rebuilds the six fixed text bands and the linked `0x1e` / `0x28` row families
+  - it does **not** restore the event metadata band `+0x7ee..+0x80e`, including `[event+0x7ef]`
+- the save-side companion `0x00430d70` matches that same omission:
+  - it writes the fixed text bands plus the linked condition/effect rows
+  - it does **not** serialize the metadata band `+0x7ee..+0x80e`
 
 So the remaining late-bringup/control-lane frontier stays between reload and service rather than
 inside the already-bounded restore loop itself.

docs/control-loop-atlas/post-load-generation-paintterrain-and-save-load-restore.md

@@ -238,7 +238,10 @@ The same brush strip is tighter now too:
   broader rebuild sibling `0x00468300` rather than by a separate tagged per-record payload lane.
   text-band families at `[record+0x0e0/+0x401/+0x4ca/+0x593/+0x65c/+0x725]`, while `0x00430d70`
   writes the standalone runtime condition-row chain plus the four grouped runtime-effect row chains
-  into the packed stream. The recipe rebuild lane itself is
+  into the packed stream. That event-side bridge omits the metadata band too: direct disassembly
+  shows neither `0x0042db20` nor `0x00430d70` restoring or serializing `[record+0x7ee..+0x80e]`,
+  so bytes like `[record+0x7ef]` only flow through the separate deep-copy helper `0x0042e050`
+  rather than through the `.smp` packed-state path. The recipe rebuild lane itself is
   tighter now too: `0x00435630` resolves both token lanes through the exact live cargo-name matcher
   `cargo_collection_find_entry_id_by_exact_name` `0x0041e9f0`, fills empty token strings from the
   first live cargo entry before that match, and in mode `3` keeps reseeding the primary lane from

docs/rehost-queue.md

@@ -11,7 +11,7 @@ This file is the short active queue for the current runtime and reverse-engineer
 ## Current Active Items
 
 - Keep the periodic-company trace as the main shellless simulation frontier, with the next concrete control-lane pass focused on the ordinary loaded runtime-effect strip `0x00444d92 -> 0x00432f40(kind 8) -> 0x004323a0 -> 0x00431b20`.
-  The checked `rt3_105/maps` compact-dispatch corpus is now exported directly and partially mirrored into the periodic-company trace: `41` maps scanned, `38` with dispatch-strip rows, `318` nondirect rows total, the add-building subset is only `10` grouped occurrences across `7` descriptor keys, and the strongest broader nondirect families are now bounded too at `36` grouped occurrences across `18` maps for `nondirect-ge1e-h0001-0360-0004-0100-0200-p0000-0000-0000-ffff :: [864:4]` plus `27` across `14` maps for the mixed `[-1:4]` cluster. All of those checked rows still lack recovered trigger kind. The active open question is therefore which ordinary loaded rows acquire or bypass the missing trigger-kind control lane before they can reach placed-structure mutation opcodes.
+  The checked `rt3_105/maps` compact-dispatch corpus is now exported directly and partially mirrored into the periodic-company trace: `41` maps scanned, `38` with dispatch-strip rows, `318` nondirect rows total, the add-building subset is only `10` grouped occurrences across `7` descriptor keys, and the strongest broader nondirect families are now bounded too at `36` grouped occurrences across `18` maps for `nondirect-ge1e-h0001-0360-0004-0100-0200-p0000-0000-0000-ffff :: [864:4]` plus `27` across `14` maps for the mixed `[-1:4]` cluster. All of those checked rows still lack recovered trigger kind. The packed-state bridge is narrower than that queue head used to allow too: `0x0042db20/0x00430d70` rebuild and serialize only the fixed text bands plus the standalone and grouped row lists, while the metadata band `+0x7ee..+0x80e` is only mirrored by deep-copy helper `0x0042e050`. The active open question is therefore which ordinary loaded rows acquire or bypass the missing trigger-kind control lane before they can reach placed-structure mutation opcodes.
   The largest direct writer table is ruled out now too: `0x004d8ea0` is the shell-side `EventConditions.win` commit helper, where controls `0x4e98..0x4ea2` write `[event+0x7ef] = 0..10` on the currently selected live event, so that seed family does not explain shellless post-load bringup.
   Preserved checked control-lane detail now lives in [Periodic company control lane](rehost-queue/periodic-company-control-lane-2026-04-21.md).
 - Keep the next static Tier-2 building pass focused on the earlier seed/projection seam into `0x00412d70`, not another broad `BuildingTypes` sweep.

docs/rehost-queue/periodic-company-control-lane-2026-04-21.md

@@ -149,6 +149,12 @@ The ordinary reload path is narrower in the same negative way now too:
   - clears collection flag `[this+0x88] = 0` before returning
 - that reload path does not pass any trigger-kind argument analogous to the later `0x00432f40`
   service call
+- and the per-record helper `0x0042db20` is narrower than a full metadata restore:
+  - it conditionally rebuilds the six fixed text bands and the linked `0x1e` / `0x28` row families
+  - it does **not** restore the event metadata band `+0x7ee..+0x80e`, including `[event+0x7ef]`
+- the save-side companion `0x00430d70` matches that same omission:
+  - it writes the fixed text bands plus the linked condition/effect rows
+  - it does **not** serialize the metadata band `+0x7ee..+0x80e`
 
 So the remaining periodic-company question stays between reload and service: the checked restore
 path repopulates the rows, but the later trigger-kind gate lives only in the service strip.