From a9b6b2c80967b8fbf28ca7424350d7ddf17489bd Mon Sep 17 00:00:00 2001 From: Jan Petykiewicz Date: Sat, 18 Apr 2026 20:54:15 -0700 Subject: [PATCH] Narrow region handoff to post-load owner strip --- crates/rrt-runtime/src/smp.rs | 71 ++++++++++++++++++++++++++++++++++- docs/rehost-queue.md | 19 ++++++++++ 2 files changed, 88 insertions(+), 2 deletions(-) diff --git a/crates/rrt-runtime/src/smp.rs b/crates/rrt-runtime/src/smp.rs index d4ff2d7..67f58ef 100644 --- a/crates/rrt-runtime/src/smp.rs +++ b/crates/rrt-runtime/src/smp.rs @@ -4943,6 +4943,7 @@ fn build_region_service_trace_report( "Which restore seam re-seeds [region+0x25e] and clears [region+0x302/+0x316] before the grounded 0x00422100 -> 0x004358d0 producer/consumer cycle runs again?".to_string(), "Which stable region id or class discriminator survives save/load strongly enough to drive 0x004358d0 after the class-0 raster/id rebuilds are ruled out?".to_string(), "Which later global restore continuation after 0x00444887 rehydrates [region+0x2a4] and [region+0x310/+0x338/+0x360] once the 0x00421510 -> 0x0041f5c0 -> 0x00455fc0 path and the 0x00444b90 -> 0x00420560 per-region follow-on are both ruled down?".to_string(), + "Which post-load generation owner under 0x004384d0 actually republishes acquisition-side region lanes after world_load_saved_runtime_state_bundle returns: the 319 placed-structure replay strip, the 320 building setup strip, or the 321 economy-seeding tail?".to_string(), "How far can the grounded 0x00420030/0x00420280 plus 0x0047efe0 connection chain be rehosted directly before the transient queued-notice family matters again?".to_string(), ]; let candidate_consumer_hypotheses = vec![ @@ -5049,6 +5050,29 @@ fn build_region_service_trace_report( "the later region-local rebuild now looks stronger than territory refresh 0x00487c20 or the broader support seam 0x0040b5d0, but the exact restore owner below the 0x00444887 continuation is still not grounded".to_string(), ], }, + SmpServiceConsumerHypothesis { + label: "post-load generation pipeline handoff".to_string(), + status: "next_post_load_owner_family".to_string(), + candidate_consumers: vec![ + "0x004384d0 world_run_post_load_generation_pipeline".to_string(), + "0x004133b0 placed_structure_collection_refresh_local_runtime_records_and_position_scalars".to_string(), + "0x00421c20 world_region_collection_run_building_population_pass".to_string(), + "0x004235c0 world_region_balance_structure_demand_and_place_candidates".to_string(), + "0x00423d30 world_region_refresh_cached_category_totals_and_weight_slots".to_string(), + "0x00437b20 simulation_run_chunked_fast_forward_burst".to_string(), + ], + evidence: vec![ + "the checked-in shell-load subgraph and function map now place world_load_saved_runtime_state_bundle 0x00446d40 directly ahead of world_run_post_load_generation_pipeline 0x004384d0, so the first later non-hook owner family after the ruled-down 0x00444887 continuation is the post-load generation strip rather than another tagged region payload callback".to_string(), + "0x004384d0 already exposes the stage ordering tightly enough to subdivide the next search: id 319 refreshes the route-entry collection, auxiliary route trackers, and then 0x004133b0 placed-structure local-runtime replay; id 320 runs 0x00421c20(1.0, 1) for the region-owned building setup strip; id 321 runs 0x00437b20 and then sweeps regions through 0x00423d30".to_string(), + "the 319 placed-structure replay strip is now grounded as more than generic setup glue: 0x004133b0 drains queued site ids through 0x0040e450, sweeps every live placed structure through 0x0040ee10, and then reaches the already-grounded linked-site follow-on 0x00480710, which is a stronger structural bridge into acquisition-side site or peer state than the ruled-down territory/support loaders".to_string(), + "the 320 building setup strip is narrower but still relevant: 0x00421c20 dispatches every live region into 0x004235c0, and that worker consults the region profile collection [region+0x37f], the placed-instance registry 0x0062b26c, and demand-balancing helpers like 0x00422900/0x00422be0/0x00422ee0, so current evidence keeps it in the same acquisition-adjacent owner family even though it is not yet a direct writer to [region+0x2a4] or [region+0x310/+0x338/+0x360]".to_string(), + "the 321 economy-seeding tail is also now bounded as a narrower cache refresh rather than generic noise: 0x00437b20 only stages a fast-forward guard and then sweeps 0x0062bae0 through 0x00423d30, which refreshes the cached category band [region+0x27a/+0x27e/+0x282/+0x286], so it remains a weaker but still explicit post-load owner family to rule in or out before returning to the deeper 0x00446d40 continuation".to_string(), + ], + blockers: vec![ + "current grounded evidence still does not show which post-load subphase actually republishes [region+0x2a4] or the cached tri-lane [region+0x310/+0x338/+0x360]".to_string(), + "0x00421c20 -> 0x004235c0 and 0x00437b20 -> 0x00423d30 are still grounded as region-side demand and cache refresh passes rather than direct restore writers, so the next static pass still needs the exact later field bridge".to_string(), + ], + }, SmpServiceConsumerHypothesis { label: "queued kind-7 modal dispatch path".to_string(), status: "shell_adjacent_reference_only".to_string(), @@ -27410,8 +27434,8 @@ mod tests { assert!(!trace.atlas_candidate_consumers.is_empty()); assert_eq!(trace.known_owner_bridge_fields.len(), 6); assert_eq!(trace.known_bridge_helpers.len(), 14); - assert_eq!(trace.next_owner_questions.len(), 4); - assert_eq!(trace.candidate_consumer_hypotheses.len(), 5); + assert_eq!(trace.next_owner_questions.len(), 5); + assert_eq!(trace.candidate_consumer_hypotheses.len(), 6); assert_eq!( trace.candidate_consumer_hypotheses[0].status, "highest_priority_static_mapping_target" @@ -27522,6 +27546,49 @@ mod tests { .any(|line| line.contains("0x00444b90") && line.contains("0x00420560")) ); + assert_eq!( + trace.candidate_consumer_hypotheses[4].status, + "next_post_load_owner_family" + ); + assert!( + trace.candidate_consumer_hypotheses[4] + .candidate_consumers + .iter() + .any(|line| line.contains("0x004384d0")) + ); + assert!( + trace.candidate_consumer_hypotheses[4] + .candidate_consumers + .iter() + .any(|line| line.contains("0x004133b0")) + ); + assert!( + trace.candidate_consumer_hypotheses[4] + .candidate_consumers + .iter() + .any(|line| line.contains("0x00421c20")) + ); + assert!( + trace.candidate_consumer_hypotheses[4] + .evidence + .iter() + .any(|line| line.contains("0x00446d40") + && line.contains("0x004384d0")) + ); + assert!( + trace.candidate_consumer_hypotheses[4] + .evidence + .iter() + .any(|line| line.contains("0x004133b0") + && line.contains("0x00480710")) + ); + assert!( + trace.candidate_consumer_hypotheses[4] + .evidence + .iter() + .any(|line| line.contains("0x00421c20") + && line.contains("0x004235c0")) + ); assert!( trace.candidate_consumer_hypotheses[1] .evidence diff --git a/docs/rehost-queue.md b/docs/rehost-queue.md index 251acbb..0a1e0a5 100644 --- a/docs/rehost-queue.md +++ b/docs/rehost-queue.md @@ -630,6 +630,25 @@ Working rule: should now bias even more toward the later region-local rebuild beneath the `0x00444887` continuation, while still keeping `0x0040b5d0` as a weaker adjacent prerequisite rather than treating it as the primary hidden owner. +- The next owner family is narrower now too: the checked-in shell-load subgraph and function map + place `world_load_saved_runtime_state_bundle` `0x00446d40` directly ahead of the post-load + generation pipeline `0x004384d0`, which is now the first explicit non-hook owner family above + the ruled-down `0x00444887` continuation. The current grounded stage order is concrete enough to + split the next static pass: `319` refreshes route entries, auxiliary route trackers, and then the + placed-structure replay strip `0x004133b0`; `320` runs the region-owned building setup strip + `0x00421c20 -> 0x004235c0`; and `321` runs the economy-seeding burst `0x00437b20` plus the + cached region summary refresher `0x00423d30`. That means the next region closure pass should + chase this `0x004384d0` handoff family directly instead of treating the remaining + `[region+0x2a4]` / `[region+0x310/+0x338/+0x360]` gap as a generic continuation below + `0x00444887`. +- The `319` lane is the strongest bridge inside that family: `0x004133b0` drains queued + placed-structure ids through `0x0040e450`, sweeps every live site through `0x0040ee10`, and then + reaches the already-grounded linked-site follow-on `0x00480710`. The `320` and `321` lanes are + still explicit but weaker: `0x00421c20 -> 0x004235c0` stays on region-side demand balancing and + structure placement, while `0x00437b20 -> 0x00423d30` only refreshes the cached category band + `[region+0x27a/+0x27e/+0x282/+0x286]`. So the next non-hook region work should start from the + post-load `319` placed-structure replay seam and only then revisit the narrower region-side + `320/321` branches if the exact field bridge is still missing. - The later restore-side region owners are narrowed further now too: the `0x00421ce0 -> 0x0041fb00 -> 0x00421730` sweep is class-`0` raster/id rebuild, `0x004881b0` is a companion region-set cell-count rebuild over `[region+0x3d/+0x41]`, `0x00487de0` is a border-segment