feat: reloadApplication for JS bundle restart without restarting app process

NativeScript/NativeScript.h

@@ -26,3 +26,10 @@
 - (bool)liveSync;
 
 @end
+
+@interface NativeScriptRuntime : NSObject
+
++ (BOOL)reloadApplication;
++ (BOOL)reloadApplication:(NSString*)baseDir;
+
+@end

NativeScript/NativeScript.mm

@@ -24,6 +24,21 @@ @implementation Config
 
 @end
 
+static Config* CopyConfig(Config* config) {
+  Config* copy = [[Config alloc] init];
+  copy.BaseDir = config.BaseDir;
+  copy.ApplicationPath = config.ApplicationPath;
+  copy.MetadataPtr = config.MetadataPtr;
+  copy.IsDebug = config.IsDebug;
+  copy.LogToSystemConsole = config.LogToSystemConsole;
+  copy.ArgumentsCount = config.ArgumentsCount;
+  copy.Arguments = config.Arguments;
+  return copy;
+}
+
+static NativeScript* currentNativeScript;
+static Config* currentConfig;
+
 @implementation NativeScript
 
 extern char defaultStartOfMetadataSection __asm("section$start$__DATA$__TNSMetadata");
@@ -82,6 +97,9 @@ - (void)shutdownRuntime {
 
 - (instancetype)initializeWithConfig:(Config*)config {
   if (self = [super init]) {
+    currentNativeScript = self;
+    currentConfig = CopyConfig(config);
+
     RuntimeConfig.BaseDir = [config.BaseDir UTF8String];
     if (config.ApplicationPath != nil) {
       RuntimeConfig.ApplicationPath =
@@ -98,6 +116,15 @@ - (instancetype)initializeWithConfig:(Config*)config {
     RuntimeConfig.IsDebug = [config IsDebug];
     RuntimeConfig.LogToSystemConsole = [config LogToSystemConsole];
 
+    // Connect the JS-exposed `NativeScriptRuntime.reloadApplication(baseDir?)`
+    // global (registered by the runtime) to the Objective-C implementation below.
+    tns::SetReloadApplicationHook([](const std::string& baseDir) -> bool {
+      NSString* dir = baseDir.empty()
+                          ? nil
+                          : [NSString stringWithUTF8String:baseDir.c_str()];
+      return [NativeScriptRuntime reloadApplication:dir] == YES;
+    });
+
     Runtime::Initialize();
     runtime_ = nullptr;
     runtime_ = std::make_unique<Runtime>();
@@ -130,8 +157,37 @@ - (instancetype)initWithConfig:(Config*)config {
 }
 
 - (void)restartWithConfig:(Config*)config {
+  // Incremented before the new isolate boots so its global template bakes in
+  // the correct `NativeScriptRuntime.reloadCount` value.
+  tns::IncrementRuntimeReloadCount();
   [self shutdownRuntime];
   [self initializeWithConfig:config];
 }
 
 @end
+
+@implementation NativeScriptRuntime
+
++ (BOOL)reloadApplication {
+  return [self reloadApplication:nil];
+}
+
++ (BOOL)reloadApplication:(NSString*)baseDir {
+  if (currentNativeScript == nil || currentConfig == nil) {
+    return NO;
+  }
+
+  Config* config = CopyConfig(currentConfig);
+  if (baseDir != nil && [baseDir length] > 0) {
+    config.BaseDir = baseDir;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [currentNativeScript restartWithConfig:config];
+    [currentNativeScript runMainApplication];
+  });
+
+  return YES;
+}
+
+@end

NativeScript/runtime/ArgConverter.mm

@@ -1,6 +1,7 @@
 #include "ArgConverter.h"
 #include <Foundation/Foundation.h>
 #include <sstream>
+#include "DevFlags.h"
 #include "DictionaryAdapter.h"
 #include "Helpers.h"
 #include "Interop.h"
@@ -134,6 +135,15 @@
   Isolate* isolate = data->isolateWrapper_.Isolate();
 
   if (!data->isolateWrapper_.IsValid()) {
+    // Instance methods carry (self, _cmd) as the first two ffi args; blocks and
+    // function pointers do not, so only dereference them when present.
+    if (data->initialParamIndex_ == 2) {
+      id self_ = *static_cast<const id*>(argValues[0]);
+      SEL cmd = *static_cast<const SEL*>(argValues[1]);
+      LogDroppedDeadIsolateCallback((__bridge void*)self_, (void*)cmd);
+    } else {
+      LogDroppedDeadIsolateCallback(nullptr, nullptr);
+    }
     memset(retValue, 0, cif->rtype->size);
     return;
   }

NativeScript/runtime/ClassBuilder.h

@@ -2,6 +2,7 @@
 #define ClassBuilder_h
 
 #include "Common.h"
+#include "IsolateWrapper.h"
 #include "Metadata.h"
 
 namespace tns {
@@ -10,11 +11,13 @@ struct PropertyCallbackContext {
 public:
     PropertyCallbackContext(v8::Isolate* isolate, std::shared_ptr<v8::Persistent<v8::Function>> callback, 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

@@ -4,6 +4,7 @@
 #include <sstream>
 #include "ArgConverter.h"
 #include "Caches.h"
+#include "DevFlags.h"
 #include "FastEnumerationAdapter.h"
 #include "Helpers.h"
 #include "Interop.h"
@@ -892,6 +893,17 @@
       FFIMethodCallback getterCallback = [](ffi_cif* cif, void* retValue, void** argValues,
                                             void* userData) {
         PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
+        if (!context->isolateWrapper_.IsValid()) {
+          // The isolate that implemented this property is gone (e.g. after
+          // reloadApplication). UIKit may still query stale delegate instances
+          // (like `window` on a JS-extended UIApplicationDelegate); bail with a
+          // zeroed return instead of locking a disposed isolate.
+          id self_ = *static_cast<const id*>(argValues[0]);
+          SEL cmd = *static_cast<const SEL*>(argValues[1]);
+          LogDroppedDeadIsolateCallback((__bridge void*)self_, (void*)cmd);
+          memset(retValue, 0, cif->rtype->size);
+          return;
+        }
         v8::Locker locker(context->isolate_);
         Isolate::Scope isolate_scope(context->isolate_);
         HandleScope handle_scope(context->isolate_);
@@ -926,6 +938,12 @@
       FFIMethodCallback setterCallback = [](ffi_cif* cif, void* retValue, void** argValues,
                                             void* userData) {
         PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
+        if (!context->isolateWrapper_.IsValid()) {
+          id self_ = *static_cast<const id*>(argValues[0]);
+          SEL cmd = *static_cast<const SEL*>(argValues[1]);
+          LogDroppedDeadIsolateCallback((__bridge void*)self_, (void*)cmd);
+          return;
+        }
         v8::Locker locker(context->isolate_);
         Isolate::Scope isolate_scope(context->isolate_);
         HandleScope handle_scope(context->isolate_);

NativeScript/runtime/DevFlags.h

@@ -12,6 +12,15 @@ namespace tns {
 // Controlled by package.json setting: "logScriptLoading": true|false
 bool IsScriptLoadingLogEnabled();
 
+// Logs (behind IsScriptLoadingLogEnabled) that a native->JS callback was
+// dropped because the isolate that created it has been disposed (e.g. after
+// NativeScriptRuntime.reloadApplication / restartWithConfig). Without this,
+// UIKit dispatch to instances of classes built by a previous isolate (such as
+// a JS-extended UIApplicationDelegate or UISceneDelegate) silently no-ops.
+// `target` is an ObjC `id` and `selector` a `SEL`; either may be null when
+// the callback is a block or C function pointer rather than a method.
+void LogDroppedDeadIsolateCallback(void* target, void* selector);
+
 // Security config
 
 // In debug mode (RuntimeConfig.IsDebug): always returns true.

NativeScript/runtime/DevFlags.mm

@@ -1,4 +1,5 @@
 #import <Foundation/Foundation.h>
+#import <objc/runtime.h>
 
 #include "DevFlags.h"
 #include "Runtime.h"
@@ -13,6 +14,24 @@ bool IsScriptLoadingLogEnabled() {
   return value ? [value boolValue] : false;
 }
 
+void LogDroppedDeadIsolateCallback(void* target, void* selector) {
+  if (!IsScriptLoadingLogEnabled()) {
+    return;
+  }
+
+  if (target != nullptr && selector != nullptr) {
+    id self_ = (__bridge id)target;
+    SEL cmd = (SEL)selector;
+    NSLog(@"NativeScript: dropping call to -[%s %s] because the JS isolate that implemented it "
+          @"was disposed (e.g. after reloadApplication); reassign the delegate/callback from the "
+          @"new bundle to restore dispatch",
+          object_getClassName(self_), sel_getName(cmd));
+  } else {
+    NSLog(@"NativeScript: dropping a native callback (block or function pointer) because the JS "
+          @"isolate that implemented it was disposed (e.g. after reloadApplication)");
+  }
+}
+
 // Security config
 
 static std::once_flag s_securityConfigInitFlag;

NativeScript/runtime/Runtime.h

@@ -8,8 +8,24 @@
 #include "SpinLock.h"
 #include "libplatform/libplatform.h"
 
+#include <functional>
+#include <string>
+
 namespace tns {
 
+using ReloadApplicationHook = std::function<bool(const std::string& baseDir)>;
+void SetReloadApplicationHook(ReloadApplicationHook hook);
+bool InvokeReloadApplicationHook(const std::string& baseDir);
+
+// Number of times the runtime has been soft-rebooted in this process
+// (restartWithConfig / reloadApplication). 0 for the first boot. Exposed to JS
+// as `NativeScriptRuntime.reloadCount` so application code (e.g.
+// @nativescript/core) can detect a reloaded instance and reattach native
+// delegates (UIApplication delegate, UIScene delegates) that are still pinned
+// to classes created by the previous isolate.
+void IncrementRuntimeReloadCount();
+int GetRuntimeReloadCount();
+
 class Runtime {
  public:
   Runtime();
@@ -67,6 +83,8 @@ class Runtime {
   void DefineCollectFunction(v8::Local<v8::Context> context);
   void DefineNativeScriptVersion(v8::Isolate* isolate,
                                  v8::Local<v8::ObjectTemplate> globalTemplate);
+  void DefineNativeScriptRuntime(v8::Isolate* isolate,
+                                 v8::Local<v8::ObjectTemplate> globalTemplate);
   void DefinePerformanceObject(v8::Isolate* isolate,
                                v8::Local<v8::ObjectTemplate> globalTemplate);
   void DefineTimeMethod(v8::Isolate* isolate,

NativeScript/runtime/Runtime.mm

@@ -292,6 +292,7 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
   tns::binding::CreateInternalBindingTemplates(isolate, globalTemplateFunction);
   Local<ObjectTemplate> globalTemplate = ObjectTemplate::New(isolate, globalTemplateFunction);
   DefineNativeScriptVersion(isolate, globalTemplate);
+  DefineNativeScriptRuntime(isolate, globalTemplate);
 
   // Worker::Init(isolate, globalTemplate, isWorker);
   DefinePerformanceObject(isolate, globalTemplate);
@@ -573,6 +574,54 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
                       ToV8String(isolate, STRINGIZE_VALUE_OF(NATIVESCRIPT_VERSION)), readOnlyFlags);
 }
 
+static ReloadApplicationHook reloadApplicationHook_;
+
+void SetReloadApplicationHook(ReloadApplicationHook hook) {
+  reloadApplicationHook_ = std::move(hook);
+}
+
+bool InvokeReloadApplicationHook(const std::string& baseDir) {
+  if (!reloadApplicationHook_) {
+    return false;
+  }
+  return reloadApplicationHook_(baseDir);
+}
+
+static std::atomic<int> runtimeReloadCount_{0};
+
+void IncrementRuntimeReloadCount() { runtimeReloadCount_++; }
+
+int GetRuntimeReloadCount() { return runtimeReloadCount_.load(); }
+
+// API to trigger application reload from JS without restarting the application process.
+// Exposes `global.NativeScriptRuntime.reloadApplication(baseDir?)` to JS.
+// `NativeScriptRuntime` class is part of the runtime framework and
+// is intentionally excluded from metadata generation, so it is not reachable
+// from JS on its own.
+void Runtime::DefineNativeScriptRuntime(Isolate* isolate, Local<ObjectTemplate> globalTemplate) {
+  Local<ObjectTemplate> runtimeTemplate = ObjectTemplate::New(isolate);
+
+  Local<FunctionTemplate> reloadTemplate =
+      FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
+        Isolate* isolate = info.GetIsolate();
+        std::string baseDir;
+        if (info.Length() > 0 && info[0]->IsString()) {
+          baseDir = tns::ToString(isolate, info[0]);
+        }
+        info.GetReturnValue().Set(tns::InvokeReloadApplicationHook(baseDir));
+      });
+  runtimeTemplate->Set(ToV8String(isolate, "reloadApplication"), reloadTemplate);
+
+  // 0 on first boot, incremented on every in-process runtime restart. Lets JS
+  // (e.g. @nativescript/core) detect it is running inside a reloaded instance
+  // and reattach native delegates that UIKit still dispatches to old-bundle
+  // instances of (UIApplication delegate, UIScene delegates).
+  runtimeTemplate->Set(ToV8String(isolate, "reloadCount"),
+                       v8::Number::New(isolate, tns::GetRuntimeReloadCount()));
+
+  globalTemplate->Set(ToV8String(isolate, "NativeScriptRuntime"), runtimeTemplate);
+}
+
 void Runtime::DefineTimeMethod(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate) {
   Local<FunctionTemplate> timeFunctionTemplate =
       FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {