fix: keep the main isolate across reloadApplication

Disposing the isolate killed JS-backed UIApplicationDelegate and
UIWindowSceneDelegate IMPs. reloadApplication now flushes module
caches and invokes __onApplicationReload on the existing isolate
instead of restartWithConfig or UIApplicationMain.

TestRunner native callbacks msgSend into JS app and scene delegates
before and after reload to prove those IMPs stay alive.

Author: NathanWalker

NativeScript/NativeScript.h

@@ -16,6 +16,11 @@
 
 - (instancetype)initWithConfig:(Config*)config;
 - (void)runScriptString: (NSString*) script runLoop: (BOOL) runLoop;
+
+/**
+ Embedder-only: dispose the isolate and construct a new Runtime.
+ JS-bootstrapped apps must not use this — it kills JS-backed delegates.
+ */
 - (void)restartWithConfig:(Config*)config;
 - (void)shutdownRuntime;
 
@@ -29,6 +34,13 @@
 
 @interface NativeScriptRuntime : NSObject
 
+/**
+ Reset the JS application on the existing main isolate.
+ Does not dispose the isolate, create a second Runtime, or re-enter
+ UIApplicationMain. JS-backed AppDelegate / UIScene delegates stay alive.
+ Optional baseDir points later module loads at an OTA bundle. After flushing
+ module caches, invokes global.__onApplicationReload if present.
+ */
 + (BOOL)reloadApplication;
 + (BOOL)reloadApplication:(NSString*)baseDir;
 

NativeScript/NativeScript.mm

@@ -33,9 +33,24 @@ @implementation Config
   return copy;
 }
 
+static void ApplyRuntimeConfigPaths(Config* config) {
+  RuntimeConfig.BaseDir = [config.BaseDir UTF8String];
+  if (config.ApplicationPath != nil) {
+    RuntimeConfig.ApplicationPath =
+        [[config.BaseDir stringByAppendingPathComponent:config.ApplicationPath] UTF8String];
+  } else {
+    RuntimeConfig.ApplicationPath =
+        [[config.BaseDir stringByAppendingPathComponent:@"app"] UTF8String];
+  }
+}
+
 static NativeScript* currentNativeScript;
 static Config* currentConfig;
 
+@interface NativeScript ()
+- (void)reloadJsApplication;
+@end
+
 @implementation NativeScript
 
 extern char defaultStartOfMetadataSection __asm("section$start$__DATA$__TNSMetadata");
@@ -84,14 +99,7 @@ - (instancetype)initializeWithConfig:(Config*)config {
     currentNativeScript = self;
     currentConfig = CopyConfig(config);
 
-    RuntimeConfig.BaseDir = [config.BaseDir UTF8String];
-    if (config.ApplicationPath != nil) {
-      RuntimeConfig.ApplicationPath =
-          [[config.BaseDir stringByAppendingPathComponent:config.ApplicationPath] UTF8String];
-    } else {
-      RuntimeConfig.ApplicationPath =
-          [[config.BaseDir stringByAppendingPathComponent:@"app"] UTF8String];
-    }
+    ApplyRuntimeConfigPaths(config);
     if (config.MetadataPtr != nil) {
       RuntimeConfig.MetadataPtr = [config MetadataPtr];
     } else {
@@ -141,10 +149,20 @@ - (instancetype)initWithConfig:(Config*)config {
 }
 
 - (void)restartWithConfig:(Config*)config {
+  // Embedder-only isolate replacement. JS-bootstrapped apps must use
+  // reloadApplication, which keeps the one main isolate alive.
+  tns::IncrementRuntimeReloadCount();
   [self shutdownRuntime];
   [self initializeWithConfig:config];
 }
 
+- (void)reloadJsApplication {
+  if (runtime_ == nullptr) {
+    return;
+  }
+  runtime_->ReloadJsApplication();
+}
+
 @end
 
 @implementation NativeScriptRuntime
@@ -158,15 +176,20 @@ + (BOOL)reloadApplication:(NSString*)baseDir {
     return NO;
   }
 
-  Config* config = CopyConfig(currentConfig);
   if (baseDir != nil && [baseDir length] > 0) {
-    config.BaseDir = baseDir;
+    currentConfig.BaseDir = baseDir;
+    ApplyRuntimeConfigPaths(currentConfig);
   }
 
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [currentNativeScript restartWithConfig:config];
-    [currentNativeScript runMainApplication];
-  });
+  void (^work)(void) = ^{
+    [currentNativeScript reloadJsApplication];
+  };
+
+  if ([NSThread isMainThread]) {
+    work();
+  } else {
+    dispatch_async(dispatch_get_main_queue(), work);
+  }
 
   return YES;
 }

NativeScript/runtime/ClassBuilder.h

@@ -2,6 +2,7 @@
 #define ClassBuilder_h
 
 #include "Common.h"
+#include "IsolateWrapper.h"
 #include "Metadata.h"
 
 namespace tns {
@@ -14,10 +15,12 @@ struct PropertyCallbackContext {
       std::shared_ptr<v8::Persistent<v8::Object>> implementationObject,
       const PropertyMeta* meta)
       : isolate_(isolate),
+        isolateWrapper_(isolate),
         callback_(callback),
         implementationObject_(implementationObject),
         meta_(meta) {}
   v8::Isolate* isolate_;
+  IsolateWrapper isolateWrapper_;
   std::shared_ptr<v8::Persistent<v8::Function>> callback_;
   std::shared_ptr<v8::Persistent<v8::Object>> implementationObject_;
   const PropertyMeta* meta_;

NativeScript/runtime/ClassBuilder.mm

@@ -903,6 +903,10 @@ void ScopeClassNameToIsolate(std::string& name, int isolateId) {
       FFIMethodCallback getterCallback = [](ffi_cif* cif, void* retValue, void** argValues,
                                             void* userData) {
         PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
+        if (!context->isolateWrapper_.IsValid()) {
+          memset(retValue, 0, cif->rtype->size);
+          return;
+        }
         Isolate* isolate = context->isolate_;
         // Scopes-before-@throw: a branded escape is captured and @thrown only
         // after every V8 scope in the inner block has destructed.
@@ -953,6 +957,9 @@ void ScopeClassNameToIsolate(std::string& name, int isolateId) {
       FFIMethodCallback setterCallback = [](ffi_cif* cif, void* retValue, void** argValues,
                                             void* userData) {
         PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
+        if (!context->isolateWrapper_.IsValid()) {
+          return;
+        }
         Isolate* isolate = context->isolate_;
         NSException* __strong pendingThrow = nil;
         {

NativeScript/runtime/Helpers.h

@@ -422,6 +422,7 @@ std::string GetSmartStackTrace(v8::Isolate* isolate, v8::TryCatch* tryCatch = nu
                                v8::Local<v8::Value> exception = v8::Local<v8::Value>());
 
 bool LiveSync(v8::Isolate* isolate);
+bool InvokeApplicationReload(v8::Isolate* isolate);
 
 void Assert(bool condition, v8::Isolate* isolate = nullptr,
             std::string const& reason = std::string());

NativeScript/runtime/Helpers.mm

@@ -736,6 +736,34 @@ void DispatchReleasedAccessMicrotask(void* data) {
   return stringResult;
 }
 
+bool tns::InvokeApplicationReload(Isolate* isolate) {
+  v8::Locker locker(isolate);
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  Local<Context> context = cache->GetContext();
+  Local<Object> global = context->Global();
+  Local<Value> value;
+  bool success =
+      global->Get(context, tns::ToV8String(isolate, "__onApplicationReload")).ToLocal(&value);
+  if (!success || value.IsEmpty() || !value->IsFunction()) {
+    return false;
+  }
+
+  Local<v8::Function> reloadFunc = value.As<v8::Function>();
+  Local<Value> result;
+  TryCatch tc(isolate);
+  success = reloadFunc->Call(context, v8::Undefined(isolate), 0, nullptr).ToLocal(&result);
+  if (!success || tc.HasCaught()) {
+    if (tc.HasCaught()) {
+      tns::LogError(isolate, tc);
+    }
+    return false;
+  }
+
+  return true;
+}
+
 bool tns::LiveSync(Isolate* isolate) {
   v8::Locker locker(isolate);
   Isolate::Scope isolate_scope(isolate);

NativeScript/runtime/ModuleInternal.h

@@ -11,6 +11,7 @@ class ModuleInternal {
   ModuleInternal(v8::Local<v8::Context> context);
   bool RunModule(v8::Isolate* isolate, std::string path);
   void RunScript(v8::Isolate* isolate, std::string script);
+  void ClearLoadedModules();
   static v8::Local<v8::Value> LoadScript(v8::Isolate* isolate,
                                          const std::string& path);
 

NativeScript/runtime/ModuleInternal.mm

@@ -129,6 +129,8 @@ static bool IsBareSpecifier(const std::string& specifier) {
   }
 }
 
+void ModuleInternal::ClearLoadedModules() { this->loadedModules_.clear(); }
+
 bool ModuleInternal::RunModule(Isolate* isolate, std::string path) {
   std::shared_ptr<Caches> cache = Caches::Get(isolate);
   Local<Context> context = cache->GetContext();

NativeScript/runtime/ModuleInternalCallbacks.h

@@ -13,6 +13,7 @@ extern std::unordered_map<std::string, v8::Global<v8::Module>> g_moduleRegistry;
 // Utility to drop modules from the registry when compilation/instantiation
 // fails
 void RemoveModuleFromRegistry(const std::string& canonicalPath);
+void ClearModuleRegistry();
 
 // Keep a fallback copy of the last evaluated module so could be served while
 // reloading if needed

NativeScript/runtime/ModuleInternalCallbacks.mm

@@ -301,6 +301,21 @@ static inline bool StartsWith(const std::string& s, const char* prefix) {
   return s_docsDir;
 }
 
+void ClearModuleRegistry() {
+  for (auto& kv : g_moduleRegistry) {
+    kv.second.Reset();
+  }
+  g_moduleRegistry.clear();
+  for (auto& kv : g_moduleFallbackRegistry) {
+    kv.second.Reset();
+  }
+  g_moduleFallbackRegistry.clear();
+  for (auto& kv : g_moduleFallbackByRelative) {
+    kv.second.Reset();
+  }
+  g_moduleFallbackByRelative.clear();
+}
+
 void RemoveModuleFromRegistry(const std::string& canonicalPath) {
   // Defensive: never operate on an anomalous/sentinel key.
   // This covers the bare "@" anomaly and the special invalid-at stub module used by the dev HTTP