feat: improved exception handling to not stop execution and show stack to allow continued development during debug

Author: NathanWalker

NativeScript/runtime/ModuleInternal.mm

@@ -522,8 +522,22 @@ throw NativeScriptException(isolate,
   }
 
   Local<Script> script = ModuleInternal::LoadClassicScript(isolate, path);
-  // run it and return the value
-  return script->Run(isolate->GetCurrentContext()).ToLocalChecked();
+
+  // run it and return the value with proper exception handling
+  Local<Context> context = isolate->GetCurrentContext();
+  TryCatch tc(isolate);
+  Local<Value> result;
+
+  if (!script->Run(context).ToLocal(&result)) {
+    // Script execution failed, throw a proper exception instead of aborting V8
+    if (tc.HasCaught()) {
+      throw NativeScriptException(isolate, tc, "Cannot execute script " + path);
+    } else {
+      throw NativeScriptException(isolate, "Script execution failed for " + path);
+    }
+  }
+
+  return result;
 }
 
 Local<Script> ModuleInternal::LoadClassicScript(Isolate* isolate, const std::string& path) {
@@ -709,7 +723,14 @@ ScriptOrigin origin(
   ScriptCompiler::CompileOptions options = ScriptCompiler::kNoCompileOptions;
   ScriptCompiler::Source source(tns::ToV8String(isolate, scriptString));
   TryCatch tc(isolate);
-  Local<Script> script = ScriptCompiler::Compile(context, &source, options).ToLocalChecked();
+
+  // Handle script compilation safely
+  Local<Script> script;
+  if (!ScriptCompiler::Compile(context, &source, options).ToLocal(&script)) {
+    // Compilation failed - return empty MaybeLocal to indicate failure
+    return MaybeLocal<Value>();
+  }
+
   MaybeLocal<Value> result = script->Run(context);
   return result;
 }

NativeScript/runtime/NativeScriptException.mm

@@ -3,6 +3,7 @@
 #include "Caches.h"
 #include "Helpers.h"
 #include "Runtime.h"
+#include "RuntimeConfig.h"
 
 using namespace v8;
 
@@ -148,6 +149,56 @@
         Exception::Error(tns::ToV8String(isolate, "No javascript exception or message provided."));
   }
 
+  // For critical exceptions (like module loading failures), provide detailed error reporting
+  bool isCriticalException = false;
+
+  // Check if this is a critical exception that should show detailed error info
+  if (!this->message_.empty()) {
+    // Module-related errors should show detailed stack traces
+    isCriticalException =
+        (this->message_.find("Error calling module function") != std::string::npos ||
+         this->message_.find("Cannot evaluate module") != std::string::npos ||
+         this->message_.find("Cannot instantiate module") != std::string::npos ||
+         this->message_.find("Cannot compile") != std::string::npos);
+  }
+
+  if (isCriticalException) {
+    // Create detailed error message similar to OnUncaughtError
+    std::string stackTrace = this->stackTrace_;
+    std::string fullMessage;
+
+    if (!this->fullMessage_.empty()) {
+      fullMessage = this->fullMessage_;
+    } else {
+      fullMessage = this->message_ + "\n at \n" + stackTrace;
+    }
+
+    // Always log the detailed error for critical exceptions (both debug and release)
+    NSLog(@"***** JavaScript exception occurred - detailed stack trace follows *****\n");
+    NSLog(@"NativeScript encountered an error:");
+    NSString* errorStr = [NSString stringWithUTF8String:fullMessage.c_str()];
+    if (errorStr != nil) {
+      NSLog(@"%@", errorStr);
+    } else {
+      NSLog(@"(error message contained invalid UTF-8)");
+    }
+
+    // In debug mode, continue execution; in release mode, terminate
+    if (RuntimeConfig.IsDebug) {
+      NSLog(@"***** End stack trace - continuing execution *****\n");
+      // In debug mode, just throw the exception normally - don't terminate
+      isolate->ThrowException(errObj);
+      return;
+    } else {
+      NSLog(@"***** End stack trace - terminating application *****\n");
+      // In release mode, create proper message and call OnUncaughtError for termination
+      Local<v8::Message> message = Exception::CreateMessage(isolate, errObj);
+      OnUncaughtError(message, errObj);
+      return;  // OnUncaughtError will terminate, so we don't continue
+    }
+  }
+
+  // For non-critical exceptions, just re-throw normally
   isolate->ThrowException(errObj);
 }
 

TestRunner/app/tests/ExceptionHandlingTests.js

@@ -0,0 +1,79 @@
+describe("Exception Handling Tests", function () {
+    it("should provide detailed stack trace for undefined global property access without crashing in debug mode", function (done) {
+        // This test simulates the exact scenario mentioned in the issue:
+        // global.CanvasModule.__addFontFamily('poppins', [font]);
+        // where CanvasModule is undefined
+        
+        let originalOnUncaughtError = global.__onUncaughtError;
+        let errorCaught = false;
+        let errorDetails = null;
+        
+        // In debug mode, the error should be caught by a regular try/catch
+        // rather than the uncaught error handler, since the app doesn't crash
+        
+        try {
+            // Simulate the problematic code from bundle.js
+            // This will throw "Cannot read properties of undefined (reading '__addFontFamily')"
+            global.CanvasModule.__addFontFamily('poppins', []);
+            
+            // Should not reach here
+            done(new Error("Expected error to be thrown"));
+        } catch (error) {
+            // In debug mode, this should be caught here instead of crashing
+            expect(error).toBeDefined();
+            expect(error.message).toContain("Cannot read properties of undefined");
+            
+            console.log("✓ Development-friendly error handling:");
+            console.log("Message:", error.message);
+            console.log("✓ App continues running without crash");
+            
+            done();
+        }
+    });
+    
+    it("should provide detailed error logging for critical exceptions in debug mode", function (done) {
+        // This test checks that critical exceptions log detailed info without crashing
+        
+        try {
+            // Trigger a reference error that would normally cause detailed logging
+            someNonExistentGlobalFunction.call();
+            done(new Error("Expected error to be thrown"));
+        } catch (error) {
+            expect(error).toBeDefined();
+            expect(error.name).toBe("ReferenceError");
+            console.log("✓ Reference error handled gracefully:");
+            console.log("Message:", error.message);
+            console.log("✓ App continues running");
+            done();
+        }
+    });
+    
+    it("should demonstrate hot-reload friendly error handling", function (done) {
+        // This test simulates what happens when you have an error in your code
+        // but want to fix it and hot-reload without the app crashing
+        
+        let errorCount = 0;
+        let successCount = 0;
+        
+        // Simulate multiple error-fix cycles
+        for (let i = 0; i < 3; i++) {
+            try {
+                if (i < 2) {
+                    // First two iterations: cause errors (simulating buggy code)
+                    global.someUndefinedObject.method();
+                } else {
+                    // Third iteration: success (simulating fixed code)
+                    successCount++;
+                }
+            } catch (error) {
+                errorCount++;
+                console.log(`Iteration ${i + 1}: Caught error (${error.message}) - app continues`);
+            }
+        }
+        
+        expect(errorCount).toBe(2);
+        expect(successCount).toBe(1);
+        console.log("✓ Hot-reload friendly: 2 errors caught, 1 success, app never crashed");
+        done();
+    });
+}); 

TestRunner/app/tests/index.js

@@ -84,6 +84,9 @@ require("./URL");
 require("./URLSearchParams");
 require("./URLPattern");
 
+// Exception handling tests
+require("./ExceptionHandlingTests");
+
 // Tests common for all runtimes.
 require("./shared/index").runAllTests();