Embed RHS 1.9 compatibility; record Workshop 0.0.141

docs/evidence/integration-check-2026-11-05/source/tests/test_observer_ownership.py

@@ -0,0 +1,148 @@
+"""Actual observer monitor/recovery/cleanup; native camera lifecycle is doubled."""
+import os,re
+from pathlib import Path
+from policy_harness import ROOT,body,run
+p=Path(os.environ.get('ERR_OBSERVER_SOURCE',ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_Observer.c'))
+game_mode=Path(os.environ.get('ERR_GAME_MODE_SOURCE',ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_GameMode.c'))
+binder=body(game_mode,'protected void BindLocalObserver(')
+binder=binder.replace('protected ', '').replace('SCR_PlayerController controller = SCR_PlayerController.Cast(GetGame().GetPlayerController());','Controller* controller = static_cast<Controller*>(GetGame()->GetPlayerController());')
+binder=binder.replace('GetGame().','GetGame()->').replace('GetCallqueue().','GetCallqueue()->').replace('Remove(BindLocalObserver)','Remove(this)').replace('controller.','controller->')
+def cpp(s):
+ s=s.replace('protected ','').replace('null','nullptr')
+ for n in ('ERR_GameMode','ERR_Actors','ERR_ObserverRules','ERR_ObserverGuidance','SCR_HintManagerComponent','SCR_RespawnSystemComponent','SCR_EditorManagerEntity','Resource','SCR_ManualCamera','RplId','ETransformMode','LogLevel','System'):
+  s=s.replace(n+'.',n+'::')
+ for n in ('ERR_GameMode','SCR_HintManagerComponent','SCR_RespawnSystemComponent','SCR_EditorManagerEntity','Resource','CameraManager','CameraBase'):
+  s=re.sub(r'\b'+n+r' (\w+)',n+r'* \1',s)
+ for n in ('mode','hints','respawn','editor','resource','manager','m_ERRObserverCamera'):
+  s=s.replace(n+'.',n+'->')
+ s=s.replace('GetGame().','GetGame()->').replace('GetWorld().','GetWorld()->').replace('GetCallqueue().','GetCallqueue()->')
+ s=s.replace('Remove(ERR_UpdateObserverClient)','Remove(this)').replace('CallLater(ERR_UpdateObserverClient, 250, true)','CallLater(this, 250, true)')
+ s=s.replace('EntitySpawnParams params = new EntitySpawnParams();','EntitySpawnParams params;')
+ return s
+methods='\n'.join(cpp(body(p,n)) for n in ('void ERR_StartObserverMonitor(', 'protected void ERR_UpdateObserverClient(', 'protected void ERR_UpdateRecoveryCamera(', 'protected void ERR_CloseObserverCamera('))
+run(r'''#include <cassert>
+#include <set>
+#include <string>
+struct string:std::string {using std::string::string;using std::string::operator=;string(std::string s):std::string(s){}bool IsEmpty()const{return empty();}};
+struct Actor {bool alive=true,conscious=true;};using IEntity=Actor*;
+struct ERR_Actors {static bool Alive(IEntity a){return a&&a->alive;}static bool CanFight(IEntity a){return Alive(a)&&a->conscious;}};
+struct ERR_GameMode {string RecoveryStatus(){return "";}bool active=true;static ERR_GameMode*current;static ERR_GameMode*Get(){return current;}bool Active(){return active;}} mode;
+ERR_GameMode*ERR_GameMode::current=&mode;
+struct ERR_ObserverRules {static bool View(int reason,bool active,bool alive,bool conscious){return active&&((reason==4&&alive&&!conscious)||(reason!=0&&!alive));}};
+struct ERR_ObserverGuidance {static bool Refresh(bool ready,int oldReason,int reason,bool oldAvailable,bool available){return !ready||oldReason!=reason||oldAvailable!=available;}static string Message(int,bool){return "spectating";}};
+struct Vec{Vec operator+(const char*)const{return {};}};
+struct EntitySpawnParams{int TransformMode=0;Vec Transform[4];};namespace ETransformMode{enum{WORLD};}
+struct Resource{static Resource*Load(const char*){static Resource r;return &r;}bool IsValid(){return true;}};
+struct CameraBase{virtual ~CameraBase()=default;};
+struct CameraManager{CameraBase*current=nullptr;int sets=0;CameraBase*CurrentCamera(){return current;}void SetCamera(CameraBase*c){current=c;sets++;}} manager;
+int terminated=0,deleted=0,explicitSwitch=0;
+struct SCR_ManualCamera:CameraBase{
+ CameraBase*previous=nullptr;bool ended=false;
+ static SCR_ManualCamera*Cast(SCR_ManualCamera*c){return c;}
+ void TrySwitchToControlledEntityCamera(){explicitSwitch++;}
+ void Terminate(){if(!ended){ended=true;terminated++;}}
+ // SDK SCR_ManualCamera destructor invokes SwitchToPreviousCamera, which
+ // changes only its own currently selected camera, never a foreign current one.
+ ~SCR_ManualCamera(){Terminate();if(manager.current==this&&previous)manager.SetCamera(previous);deleted++;}
+};
+struct SCR_HintManagerComponent{int attempts=0;bool silent=false;static SCR_HintManagerComponent*GetInstance(){static SCR_HintManagerComponent h;return &h;}bool ShowCustom(string,string,int,bool quiet=false){attempts++;silent=quiet;return true;}};
+struct SCR_RespawnSystemComponent{int clears=0;static SCR_RespawnSystemComponent*GetInstance(){static SCR_RespawnSystemComponent r;return &r;}void DestroyLoadingPlaceholder(){clears++;}};
+struct SCR_EditorManagerEntity{bool opened=false;int closes=0;static SCR_EditorManagerEntity*GetInstance(){static SCR_EditorManagerEntity e;return &e;}bool IsOpened(){return opened;}void Close(bool){opened=false;closes++;}};
+struct RplId{static int Invalid(){return -1;}};namespace LogLevel{enum{WARNING};}void Print(const char*,int){}
+namespace System{int now=0;int GetTickCount(){return now;}bool IsConsoleApp(){return false;}}
+struct Queue{std::set<void*>owners;int added=0;void CallLater(void*owner,int,bool){owners.insert(owner);added++;}void Remove(void*owner){owners.erase(owner);}} queue;
+struct World{float now=1;float GetWorldTime(){return now;}} world;
+struct Game{void*local=nullptr;int spawns=0;void*GetPlayerController(){return local;}Queue*GetCallqueue(){return &queue;}World*GetWorld(){return &world;}CameraManager*GetCameraManager(){return &manager;}
+ SCR_ManualCamera*SpawnEntityPrefabLocal(Resource*,World*,EntitySpawnParams){spawns++;auto*c=new SCR_ManualCamera();c->previous=manager.current;manager.SetCamera(c);return c;}} game;
+bool gameAvailable=true;Game*GetGame(){return gameAvailable?&game:nullptr;}
+struct Controller{
+ string ERR_SelfEpinephrineHint(){return "";}
+ IEntity actor=nullptr,m_ERRRecoveryBody=nullptr;float m_ERRRecoveryDeadline=-1;
+ bool m_ERRObserverMonitor=false,m_ERRObserverReady=false,m_ERRShownObserverAvailable=false;
+ string m_ERRShownRecoveryStatus,m_ERRPendingRecoveryStatus;
+ int m_ERRRecoveryStatusSince=0;
+ int m_ERRObserverReason=0,m_ERRShownObserverReason=0,m_ERRObservedId=1,starts=0;
+ Vec m_ERRObserverAnchor;SCR_ManualCamera*m_ERRObserverCamera=nullptr;CameraBase*playerCamera=nullptr;
+ IEntity GetControlledEntity(){return actor;}CameraBase*GetPlayerCamera(){return playerCamera;}
+ void ERR_OnObserverMonitorStarted(){starts++;}
+'''+methods+r'''
+};
+struct Binder {bool m_Stopped=false,m_NativeEndHandled=false;
+'''+binder+r'''
+};
+int main(){
+ // The real repeating binder must survive the first controller and gaps.
+ Binder binder;Controller first,replacement;queue.owners.insert(&binder);
+ game.local=nullptr;binder.BindLocalObserver();assert(queue.owners.count(&binder)&&queue.added==0);
+ game.local=&first;binder.BindLocalObserver();
+ assert(first.m_ERRObserverMonitor&&first.starts==1&&queue.owners.count(&first));
+ assert(queue.owners.count(&binder));
+ binder.BindLocalObserver();assert(first.starts==1&&queue.added==1);
+ game.local=nullptr;binder.BindLocalObserver();assert(queue.owners.count(&binder));
+ game.local=&replacement;binder.BindLocalObserver();
+ assert(replacement.m_ERRObserverMonitor&&replacement.starts==1&&queue.owners.count(&replacement));
+ first.ERR_UpdateObserverClient();
+ assert(!first.m_ERRObserverMonitor&&!queue.owners.count(&first)&&queue.owners.count(&replacement));
+ binder.BindLocalObserver();assert(replacement.starts==1&&queue.added==2);
+ binder.m_Stopped=true;binder.BindLocalObserver();assert(!queue.owners.count(&binder)&&queue.owners.count(&replacement));
+ binder.m_Stopped=false;binder.m_NativeEndHandled=true;queue.owners.insert(&binder);binder.BindLocalObserver();
+ assert(!queue.owners.count(&binder)&&queue.owners.count(&replacement)&&queue.added==2);
+ queue.owners.clear();queue.added=0;game.local=nullptr;
+
+ Actor body;CameraBase formerBodyCamera,newBodyCamera;
+ Controller former,current;former.actor=&body;former.playerCamera=&formerBodyCamera;
+ game.local=&former;manager.current=&formerBodyCamera;former.ERR_StartObserverMonitor();
+ body.conscious=false;former.m_ERRObserverReason=4;former.ERR_UpdateObserverClient();
+ assert(former.m_ERRRecoveryBody==&body&&former.m_ERRObserverCamera&&queue.owners.count(&former));
+ SCR_ManualCamera*oldOwned=former.m_ERRObserverCamera;
+ // New controller owns a separate spectator camera; old body wakes meanwhile.
+ current.playerCamera=&newBodyCamera;current.m_ERRObserverReason=1;game.local=&current;current.ERR_StartObserverMonitor();current.ERR_UpdateObserverClient();
+ SCR_ManualCamera*newOwned=current.m_ERRObserverCamera;assert(newOwned&&newOwned!=oldOwned&&manager.current==newOwned);
+ auto*editor=SCR_EditorManagerEntity::GetInstance();editor->opened=true;body.conscious=true;
+ int beforeClears=SCR_RespawnSystemComponent::GetInstance()->clears;
+ int beforeSets=manager.sets,beforeHints=SCR_HintManagerComponent::GetInstance()->attempts,beforeSpawns=game.spawns,beforeDeleted=deleted;
+ former.ERR_UpdateObserverClient();
+ assert(manager.current==newOwned&&manager.sets==beforeSets&&editor->opened&&editor->closes==0);
+ assert(!former.m_ERRRecoveryBody&&former.m_ERRRecoveryDeadline==-1&&!former.m_ERRObserverMonitor&&!former.m_ERRObserverCamera);
+ assert(deleted==beforeDeleted+1&&terminated==deleted&&explicitSwitch==0);
+ assert(current.m_ERRObserverCamera==newOwned&&queue.owners.count(&current)==1&&queue.owners.count(&former)==0);
+ assert(SCR_HintManagerComponent::GetInstance()->attempts==beforeHints&&game.spawns==beforeSpawns&&SCR_RespawnSystemComponent::GetInstance()->clears==beforeClears);
+ // Even a queued stale spectator callback cannot create a camera or a hint.
+ former.actor=nullptr;former.m_ERRObserverReason=1;former.ERR_UpdateObserverClient();
+ assert(game.spawns==beforeSpawns&&manager.current==newOwned&&SCR_HintManagerComponent::GetInstance()->attempts==beforeHints);
+ // Start is still local-only; reacquisition restarts exactly one owned timer.
+ int added=queue.added;former.ERR_StartObserverMonitor();assert(queue.added==added);
+ game.local=&former;former.actor=&body;former.m_ERRObserverReason=0;former.ERR_StartObserverMonitor();former.ERR_StartObserverMonitor();
+ assert(queue.added==added+1&&former.starts==2&&queue.owners.count(&current)==1);
+ // Normal recovery still closes the editor and returns this controller's body.
+ body.conscious=false;former.ERR_UpdateObserverClient();assert(former.m_ERRRecoveryBody==&body);
+ body.conscious=true;former.ERR_UpdateObserverClient();assert(manager.current==&formerBodyCamera&&!editor->opened&&editor->closes==1&&!former.m_ERRRecoveryBody);
+ // Foreign current camera survives this controller's retained camera cleanup.
+ game.local=&current;manager.current=&newBodyCamera;current.ERR_CloseObserverCamera();assert(manager.current==&newBodyCamera&&deleted==beforeDeleted+2);
+ // If the old owned camera is still current at replacement, its native
+ // destructor may restore its own previous camera; no new-controller camera is deleted.
+ Controller abandoned;abandoned.m_ERRObserverReason=1;game.local=&abandoned;manager.current=&newBodyCamera;
+ abandoned.ERR_StartObserverMonitor();abandoned.ERR_UpdateObserverClient();assert(manager.current==abandoned.m_ERRObserverCamera);
+ game.local=&current;beforeSets=manager.sets;beforeDeleted=deleted;abandoned.ERR_UpdateObserverClient();
+ assert(!abandoned.m_ERRObserverCamera&&manager.current==&newBodyCamera&&manager.sets==beforeSets+1&&deleted==beforeDeleted+1);
+ assert(queue.owners.count(&abandoned)==0&&queue.owners.count(&current)==1);
+ // Solo death may leave the controlled corpse assigned; restore the orbit
+ // camera if the native death camera replaces it on a later tick.
+ Controller solo;Actor corpse;corpse.alive=false;corpse.conscious=false;
+ solo.actor=&corpse;solo.m_ERRObserverReason=1;game.local=&solo;editor->opened=false;
+ solo.ERR_UpdateObserverClient();auto*corpseCamera=solo.m_ERRObserverCamera;
+ assert(corpseCamera&&manager.current==corpseCamera);
+ manager.current=&newBodyCamera;beforeClears=SCR_RespawnSystemComponent::GetInstance()->clears;beforeSpawns=game.spawns;
+ solo.ERR_UpdateObserverClient();
+ assert(manager.current==corpseCamera&&game.spawns==beforeSpawns&&SCR_RespawnSystemComponent::GetInstance()->clears==beforeClears+1);
+ // Game Master remains usable during spectating, including before first camera creation.
+ editor->opened=true;manager.current=&newBodyCamera;solo.ERR_UpdateObserverClient();
+ assert(manager.current==&newBodyCamera&&game.spawns==beforeSpawns);
+ solo.ERR_CloseObserverCamera();solo.ERR_UpdateObserverClient();
+ assert(!solo.m_ERRObserverCamera&&manager.current==&newBodyCamera&&game.spawns==beforeSpawns);
+ editor->opened=false;solo.ERR_UpdateObserverClient();assert(solo.m_ERRObserverCamera&&manager.current==solo.m_ERRObserverCamera);
+ solo.ERR_CloseObserverCamera();
+ gameAvailable=false;former.ERR_UpdateObserverClient();gameAvailable=true;
+}
+''')
+print('PASS: actual observer monitor/recovery/cleanup rejects retained old controller, preserves new camera/editor/hints/timer, restarts once and retains normal recovery; native effects modeled from SDK, no runtime claim')

docs/evidence/integration-check-2026-11-05/source/tests/test_preparation_status.py

@@ -0,0 +1,127 @@
+"""Execute loading presentation/cleanup and native observation bodies with UI adapters.
+No native layout rendering, multiplayer, or real startup-failure claim.
+"""
+from policy_harness import ROOT, body, run
+SOURCE=ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_PreparationStatus.c'
+def cpp(s):
+ s=s.replace('protected ','').replace('override ','').replace('null','nullptr')
+ s=s.replace('ERR_GameMode mode = ERR_GameMode.Get();','ERR_GameMode* mode = ERR_GameMode::Get();')
+ s=s.replace('ERR_GameMode current = ERR_GameMode::Get();','ERR_GameMode* current = ERR_GameMode::Get();')
+ s=s.replace('ERR_GameMode current = ERR_GameMode.Get();','ERR_GameMode* current = ERR_GameMode::Get();')
+ s=s.replace('current.Phase()', 'current->Phase()')
+ s=s.replace('ERR_GameMode mode,','ERR_GameMode* mode,')
+ s=s.replace('ERR_GameMode mode)', 'ERR_GameMode* mode)')
+ for name in ['System','ERR_GameMode','ERR_Phase','ERR_ObjectiveText','ERR_MissionRules','ERR_PreparationFailureMenu']:s=s.replace(name+'.',name+'::')
+ s=s.replace('TextWidget.Cast(','CastText(').replace('Widget widget)', 'Widget* widget)').replace('widget.', 'widget->')
+ for name in ['mode','m_wLoadingPlaceholder','m_ERRPreparationSpinner','m_ERRPreparationRoot','m_ERRPreparationTitle','m_ERRPreparationDescription']:
+  s=s.replace(name+'.',name+'->')
+ s=s.replace('GetGame().','GetGame()->').replace('GetWorkspace().','GetWorkspace()->').replace('.IsEmpty()','.empty()')
+ return s.replace('super.','Native::')
+methods='\n'.join(cpp(body(SOURCE,key)) for key in ('void ERR_KeepSpawnSceneLoading(', 'void ERR_ShowSpawnSceneLoading(', 'protected string ERR_PreparationDescription(', 'protected void ERR_ClearPreparationStatus(', 'override void UpdateLoadingPlaceholder(', 'override void DestroyLoadingPlaceholder(', 'protected bool ERR_PreparationWidgetVisible(', 'bool ERR_ProbePreparationVisible('))
+run(r'''
+#include <cassert>
+#include <string>
+#include <map>
+using string=std::string;
+namespace System{bool console=false;bool IsConsoleApp(){return console;}}
+namespace ERR_Phase{enum{PREPARING,PRISON,RADIO_SEARCH,RADIO_DEFENCE,EXTRACTION,VICTORY,DEFEAT};}
+namespace ERR_MissionRules{bool Terminal(int p){return p==ERR_Phase::VICTORY||p==ERR_Phase::DEFEAT;}}
+struct ERR_GameMode{static ERR_GameMode* current;int phase=ERR_Phase::PREPARING;string error;static ERR_GameMode* Get(){return current;}int Phase(){return phase;}bool Active(){return phase>=ERR_Phase::PRISON&&phase<=ERR_Phase::EXTRACTION;}string PreparationError(){return error;}};ERR_GameMode* ERR_GameMode::current=nullptr;
+namespace ERR_PreparationFailureMenu{bool shown=false;bool Show(ERR_GameMode*){return shown;}bool Visible(ERR_GameMode*){return shown;}};
+namespace ERR_ObjectiveText{string Description(ERR_GameMode* mode,bool){return mode->error.empty()?"Preparing sites":"Mission failed; ask an administrator to correct and restart";}}
+struct Widget{Widget* parent=nullptr;bool visible=true,removed=false,textWidget=false;string text;int textWrites=0,visibilityWrites=0;float width=900,height=170;std::map<string,Widget*> children;
+ void GetScreenSize(float& w,float& h){w=width;h=height;}Widget* GetParent(){return parent;}void RemoveFromHierarchy(){removed=true;parent=nullptr;}void SetVisible(bool value){visible=value;visibilityWrites++;}bool IsVisible(){return visible;}
+ Widget* FindAnyWidget(string name){return children.count(name)?children[name]:nullptr;}void SetText(string value){text=value;textWrites++;}string GetText(){return text;}};
+Widget* CastText(Widget* w){return w&&w->textWidget?w:nullptr;}
+struct Workspace{int creates=0;bool fail=false,missingText=false;Widget* CreateWidgets(const char*,Widget* parent){creates++;if(fail)return nullptr;auto root=new Widget;root->parent=parent;for(string name:{"ERR_PreparationTitle","ERR_PreparationDescription"}){auto child=new Widget;child->parent=root;child->textWidget=true;root->children[name]=child;}if(missingText)root->children.erase("ERR_PreparationTitle");return root;}};
+struct Game{Workspace workspace;Workspace* GetWorkspace(){return &workspace;}};Game game;Game* GetGame(){return &game;}
+struct Native{Widget* m_wLoadingPlaceholder=nullptr;ERR_GameMode* m_pGameMode=nullptr;int nativeUpdates=0,destroys=0;void CreateLoadingPlaceholder(){m_wLoadingPlaceholder=new Widget;}void UpdateLoadingPlaceholder(float){nativeUpdates++;}void DestroyLoadingPlaceholder(){destroys++;if(m_wLoadingPlaceholder)m_wLoadingPlaceholder->RemoveFromHierarchy();m_wLoadingPlaceholder=nullptr;}};
+struct Probe:Native{
+ Widget *m_ERRPreparationParent=nullptr,*m_ERRPreparationRoot=nullptr,*m_ERRPreparationTitle=nullptr,*m_ERRPreparationDescription=nullptr,*m_ERRPreparationSpinner=nullptr;
+ bool m_ERRKeepSpawnSceneLoading=false,m_ERRPreparationSpinnerHidden=false,m_ERRPreparationSpinnerWasVisible=false;string m_ERRPreparationLastTitle,m_ERRPreparationLastDescription;
+'''+methods+r'''
+};
+struct Fixture{ERR_GameMode mode;Widget parent,spinner;Probe p;Fixture(){game.workspace={};System::console=false;ERR_PreparationFailureMenu::shown=false;ERR_GameMode::current=&mode;p.m_pGameMode=&mode;p.m_wLoadingPlaceholder=&parent;parent.children["Spinner"]=&spinner;spinner.parent=&parent;}};
+int main(){
+ {Fixture f;f.mode.error="bad";ERR_PreparationFailureMenu::shown=true;f.p.UpdateLoadingPlaceholder(.1f);assert(!f.parent.visible&&f.p.ERR_ProbePreparationVisible(&f.mode,true));}
+ {Fixture f;f.mode.phase=ERR_Phase::PRISON;f.p.ERR_ShowSpawnSceneLoading();auto root=f.p.m_ERRPreparationRoot;f.p.ERR_KeepSpawnSceneLoading(true);f.p.DestroyLoadingPlaceholder();assert(!root->removed&&!f.parent.removed&&f.p.destroys==0);f.p.ERR_KeepSpawnSceneLoading(false);f.p.DestroyLoadingPlaceholder();assert(root->removed&&f.p.destroys==1);f.p.ERR_ShowSpawnSceneLoading();assert(f.p.m_wLoadingPlaceholder&&f.p.ERR_ProbePreparationVisible(&f.mode,false));}
+ {Fixture f;f.p.UpdateLoadingPlaceholder(.1f);assert(f.p.nativeUpdates==1&&game.workspace.creates==1&&f.p.ERR_ProbePreparationVisible(&f.mode,false));
+  Widget* root=f.p.m_ERRPreparationRoot;auto title=f.p.m_ERRPreparationTitle;auto description=f.p.m_ERRPreparationDescription;
+  for(int i=0;i<200;i++){f.p.UpdateLoadingPlaceholder(.1f);}assert(game.workspace.creates==1&&title->textWrites==1&&description->textWrites==1);
+  f.mode.error="invalid catalog";f.p.UpdateLoadingPlaceholder(.1f);assert(f.p.ERR_ProbePreparationVisible(&f.mode,true)&&!f.spinner.visible);
+  for(int i=0;i<200;i++){f.p.UpdateLoadingPlaceholder(.1f);}assert(f.p.m_ERRPreparationRoot==root&&title->textWrites==2&&description->textWrites==2&&f.spinner.visibilityWrites==1);
+  title->width=0;assert(!f.p.ERR_ProbePreparationVisible(&f.mode,true));title->width=900;f.mode.error.clear();f.p.UpdateLoadingPlaceholder(.1f);assert(f.spinner.visible&&f.p.ERR_ProbePreparationVisible(&f.mode,false));
+  f.mode.phase=ERR_Phase::PRISON;f.p.UpdateLoadingPlaceholder(.1f);assert(!root->removed&&!f.parent.removed&&f.spinner.visible&&f.p.ERR_ProbePreparationVisible(&f.mode,false));
+  assert(description->text=="Please wait while your spawn area and equipment finish loading. You will take control when preparation is complete.");
+  for(int phase=ERR_Phase::PRISON;phase<=ERR_Phase::EXTRACTION;phase++){f.mode.phase=phase;for(int i=0;i<200;i++)f.p.UpdateLoadingPlaceholder(.1f);assert(f.p.m_ERRPreparationRoot==root&&f.p.ERR_ProbePreparationVisible(&f.mode,false));}
+  f.mode.phase=ERR_Phase::VICTORY;f.p.UpdateLoadingPlaceholder(.1f);assert(root->removed&&f.parent.removed&&f.spinner.visible&&!f.p.m_ERRPreparationRoot&&f.p.destroys==1);
+ }
+ for(int phase : {ERR_Phase::VICTORY,ERR_Phase::DEFEAT}){Fixture f;f.p.UpdateLoadingPlaceholder(.1f);f.p.ERR_KeepSpawnSceneLoading(true);f.mode.phase=phase;f.p.UpdateLoadingPlaceholder(.1f);assert(f.parent.removed&&!f.p.m_ERRKeepSpawnSceneLoading&&f.p.destroys==1);}
+ {Fixture f;f.p.ERR_KeepSpawnSceneLoading(true);ERR_GameMode replacement;ERR_GameMode::current=&replacement;f.p.DestroyLoadingPlaceholder();assert(f.parent.removed&&f.p.destroys==1);}
+ {Fixture f;f.p.ERR_KeepSpawnSceneLoading(true);ERR_GameMode::current=nullptr;f.p.DestroyLoadingPlaceholder();assert(f.parent.removed&&f.p.destroys==1);}
+ for(int mismatch=0;mismatch<6;mismatch++){Fixture f;ERR_GameMode other;if(mismatch==0)ERR_GameMode::current=nullptr;if(mismatch==1)f.p.m_pGameMode=&other;if(mismatch==2)f.mode.phase=-1;if(mismatch==3)System::console=true;if(mismatch==4)f.p.m_wLoadingPlaceholder=nullptr;if(mismatch==5)f.p.m_pGameMode=nullptr;f.p.UpdateLoadingPlaceholder(.1f);assert(game.workspace.creates==0&&f.p.nativeUpdates==1&&!f.parent.removed&&f.spinner.visibilityWrites==0);}
+ {Fixture f;f.mode.phase=ERR_Phase::PRISON;f.p.UpdateLoadingPlaceholder(.1f);assert(f.p.ERR_ProbePreparationVisible(&f.mode,false));Widget* root=f.p.m_ERRPreparationRoot;f.p.DestroyLoadingPlaceholder();assert(root->removed&&f.parent.removed&&!f.p.m_ERRPreparationRoot&&f.p.destroys==1);f.p.UpdateLoadingPlaceholder(.1f);assert(game.workspace.creates==1);}
+ {Fixture f;f.mode.error="bad";f.spinner.visible=false;f.p.UpdateLoadingPlaceholder(.1f);assert(f.p.ERR_ProbePreparationVisible(&f.mode,true));f.p.ERR_ClearPreparationStatus();assert(!f.spinner.visible);}
+ {Fixture f;f.mode.error="bad";f.p.UpdateLoadingPlaceholder(.1f);Widget* old=f.p.m_ERRPreparationRoot;Widget newParent,newSpinner;newParent.children["Spinner"]=&newSpinner;newSpinner.parent=&newParent;f.p.m_wLoadingPlaceholder=&newParent;f.p.UpdateLoadingPlaceholder(.1f);assert(old->removed&&f.spinner.visible&&!newSpinner.visible&&f.p.m_ERRPreparationParent==&newParent&&game.workspace.creates==2);f.p.DestroyLoadingPlaceholder();assert(newParent.removed&&!f.parent.removed&&newSpinner.visible&&!f.p.m_ERRPreparationRoot&&f.p.destroys==1);}
+ {Fixture f;f.mode.error="bad";f.p.UpdateLoadingPlaceholder(.1f);f.p.m_ERRPreparationParent=nullptr;f.p.m_ERRPreparationRoot=nullptr;f.p.m_ERRPreparationTitle=nullptr;f.p.m_ERRPreparationDescription=nullptr;f.p.m_ERRPreparationSpinner=nullptr;f.p.m_wLoadingPlaceholder=nullptr;f.p.UpdateLoadingPlaceholder(.1f);assert(!f.p.m_ERRPreparationSpinnerHidden);}
+ {Fixture f;game.workspace.fail=true;f.p.UpdateLoadingPlaceholder(.1f);assert(!f.p.m_ERRPreparationRoot&&f.spinner.visibilityWrites==0);game.workspace.fail=false;f.p.UpdateLoadingPlaceholder(.1f);assert(f.p.ERR_ProbePreparationVisible(&f.mode,false));}
+ {Fixture f;game.workspace.missingText=true;f.p.UpdateLoadingPlaceholder(.1f);assert(!f.p.m_ERRPreparationRoot&&f.spinner.visibilityWrites==0);}
+ {Fixture f;f.p.UpdateLoadingPlaceholder(.1f);Widget other;Widget* moved=f.p.m_ERRPreparationRoot;moved->parent=&other;f.p.UpdateLoadingPlaceholder(.1f);assert(moved->removed&&f.p.m_ERRPreparationRoot!=moved&&f.p.m_ERRPreparationParent==&f.parent);}
+}
+''')
+probe=ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_NativePreparationStatusProbe.c'
+s=body(probe,'static int Tick(').replace('ERR_GameMode mode,','ERR_GameMode* mode,').replace('ERR_GameMode.Get()','ERR_GameMode::Get()').replace('ERR_Phase.PREPARING','PREPARING').replace('mode.','mode->').replace('.IsEmpty()','.empty()').replace('SCR_RespawnSystemComponent respawn','SCR_RespawnSystemComponent* respawn').replace('SCR_RespawnSystemComponent.GetInstance()','SCR_RespawnSystemComponent::GetInstance()').replace('respawn.','respawn->').replace('System.MakeScreenshot','System::MakeScreenshot')
+run(r'''
+#include <cassert>
+#include <string>
+using string=std::string;const int PREPARING=0;
+struct ERR_GameMode{static ERR_GameMode* current;int phase=0;string error="bad";static ERR_GameMode* Get(){return current;}int Phase(){return phase;}string PreparationError(){return error;}};ERR_GameMode* ERR_GameMode::current=nullptr;
+struct SCR_RespawnSystemComponent{bool visible=true;static SCR_RespawnSystemComponent instance;static SCR_RespawnSystemComponent* GetInstance(){return &instance;}bool ERR_ProbePreparationVisible(ERR_GameMode*,bool failed){assert(failed);return visible;}};SCR_RespawnSystemComponent SCR_RespawnSystemComponent::instance;
+namespace System{int captures=0;void MakeScreenshot(const char*){captures++;}}void Print(const char*){}
+struct Probe{static ERR_GameMode* s_Mode;static float s_Deadline,s_Since,s_Last,s_CaptureAt;
+'''+s+r'''
+};ERR_GameMode* Probe::s_Mode=nullptr;float Probe::s_Deadline=0,Probe::s_Since=-1,Probe::s_Last=-1,Probe::s_CaptureAt=-1;
+int main(){ERR_GameMode mode;ERR_GameMode::current=&mode;
+ for(int i=0;i<=33;i++){assert(Probe::Tick(&mode,i*500)==0);}assert(System::captures==0);assert(Probe::Tick(&mode,17000)==0&&System::captures==1);assert(Probe::Tick(&mode,17500)==1&&System::captures==1);
+ ERR_GameMode next;ERR_GameMode::current=&next;assert(Probe::Tick(&next,20000)==0);assert(Probe::Tick(&next,22000)==0&&Probe::s_Since==22000);SCR_RespawnSystemComponent::instance.visible=false;assert(Probe::Tick(&next,22500)==0&&Probe::s_Since==-1);assert(Probe::Tick(&next,50000)==-1);
+}
+''')
+text=SOURCE.read_text()
+prefab=(ROOT/'addons/core/Prefabs/ERR/GameMode.et').read_text()
+assert 'm_bUseSpawnPreload 1' in prefab and 'm_bUseSpawnPreload 0' not in prefab
+assert 'GetOwner(' not in text
+assert text.count('m_pGameMode != mode') == 3
+# m_pGameMode is the installed vanilla protected owner field, assigned by
+# SCR_RespawnSystemComponent.OnInit(IEntity owner). The adapter deliberately
+# exposes that field rather than inventing a ScriptComponent.GetOwner API.
+for forbidden in ('CallLater(', 'SetCamera(', 'SpawnEntity', 'SetControlledEntity(', 'Transition(', 'PreparationError() ='):
+ assert forbidden not in text,forbidden
+native=probe.read_text()
+for forbidden in ('CreateWidgets(', 'UpdateLoadingPlaceholder(', 'SetText(', 'SetVisible('):assert forbidden not in native
+base=(ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_NativeBaseSmoke.c').read_text()
+assert 'ERR_NativePreparationStatusProbe.Tick(this, now)' in base
+assert 'native-end-active' in base and 'native-end-preparing' in base
+print('PASS: actual preparation status scope, persistent updates, spinner restoration, placeholder replacement/deletion/destruction, native observation persistence/timeout; rendering remains native-pending')
+
+# Execute the production world-system rebind that restores frame delivery.
+source=ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_TerrainTakeoverManagers.c'
+bind=body(source,'void ERR_BindEscapeRespawn(').replace('SCR_RespawnSystemComponent respawn','Respawn* respawn').replace('ERR_GameMode mode = ERR_GameMode.Get();','Mode* mode = Mode::current;').replace('SCR_RespawnSystemComponent.Cast(mode.FindComponent(SCR_RespawnSystemComponent))','mode->respawn')
+run(r"""
+#include <cassert>
+struct Respawn{int frames=0;};struct Mode{inline static Mode* current=nullptr;Respawn* respawn=nullptr;};void Print(const char*){}
+struct System{Respawn* m_RespawnSystem=nullptr;bool m_bReady=true,enabled=false;int enables=0;void Enable(bool value){enabled=value;enables++;}
+"""+bind+r"""
+ void Frame(){if(enabled&&m_RespawnSystem)m_RespawnSystem->frames++;}
+};
+int main(){System system;Mode mode;Respawn original,replacement,unrelated;Mode::current=&mode;mode.respawn=&replacement;system.m_RespawnSystem=&original;
+ system.ERR_BindEscapeRespawn(&unrelated);assert(system.enables==0&&system.m_RespawnSystem==&original);
+ system.ERR_BindEscapeRespawn(nullptr);assert(system.enables==0);
+ system.ERR_BindEscapeRespawn(&replacement);assert(system.enabled&&!system.m_bReady&&system.m_RespawnSystem==&replacement);system.Frame();assert(replacement.frames==1&&original.frames==0);
+ system.m_bReady=true;system.ERR_BindEscapeRespawn(&replacement);assert(system.m_bReady); // Idempotent: keep current deploy readiness.
+ Mode::current=nullptr;system.ERR_BindEscapeRespawn(&original);assert(system.m_RespawnSystem==&replacement);
+}
+""")
+create=body(SOURCE,'protected override void CreateLoadingPlaceholder(')
+assert create.index('super.CreateLoadingPlaceholder()') < create.index('ERR_BindEscapeRespawn(this)')
+assert 'm_fAutoReloadTime 120' in [line.strip() for line in prefab.splitlines()]
+print('PASS: replaced respawn system receives frame updates, disabled updater wakes, stale/non-Escape binding refused; terminal and stale preload leases release black overlay')