diff --git a/.gitignore b/.gitignore
index 08fb1b04..c8be8075 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,6 +37,9 @@ Thumbs.db
 # VSCode
 .vscode
 
+# Generated by tools/js2c.mjs (Xcode "Generate RuntimeBuiltins" build phase)
+NativeScript/runtime/generated/
+
 # Other
 node_modules/
 package-lock.json
diff --git a/NativeScript/runtime/ArgConverter.h b/NativeScript/runtime/ArgConverter.h
index 64ab8d5f..8353fbb2 100644
--- a/NativeScript/runtime/ArgConverter.h
+++ b/NativeScript/runtime/ArgConverter.h
@@ -2,61 +2,128 @@
 #define ArgConverter_h
 
 #include <vector>
-#include "libffi.h"
-#include "Common.h"
+
 #include "Caches.h"
+#include "Common.h"
 #include "DataWrapper.h"
 #include "IsolateWrapper.h"
+#include "libffi.h"
 
 namespace tns {
 
 class ArgConverter;
 
 struct MethodCallbackWrapper {
-public:
-    MethodCallbackWrapper(v8::Isolate* isolate, std::shared_ptr<v8::Persistent<v8::Value>> callback, const uint8_t initialParamIndex, const uint8_t paramsCount, const TypeEncoding* typeEncoding)
-        : isolateWrapper_(isolate),
-          callback_(callback),
-          initialParamIndex_(initialParamIndex),
-          paramsCount_(paramsCount),
-          typeEncoding_(typeEncoding) {
-    }
-    IsolateWrapper isolateWrapper_;
-    std::shared_ptr<v8::Persistent<v8::Value>> callback_;
-    const uint8_t initialParamIndex_;
-    const uint8_t paramsCount_;
-    const TypeEncoding* typeEncoding_;
+ public:
+  MethodCallbackWrapper(v8::Isolate* isolate,
+                        std::shared_ptr<v8::Persistent<v8::Value>> callback,
+                        const uint8_t initialParamIndex,
+                        const uint8_t paramsCount,
+                        const TypeEncoding* typeEncoding)
+      : isolateWrapper_(isolate),
+        callback_(callback),
+        initialParamIndex_(initialParamIndex),
+        paramsCount_(paramsCount),
+        typeEncoding_(typeEncoding) {}
+  IsolateWrapper isolateWrapper_;
+  std::shared_ptr<v8::Persistent<v8::Value>> callback_;
+  const uint8_t initialParamIndex_;
+  const uint8_t paramsCount_;
+  const TypeEncoding* typeEncoding_;
 };
 
 class ArgConverter {
-public:
-    static void Init(v8::Local<v8::Context> context, v8::GenericNamedPropertyGetterCallback structPropertyGetter, v8::GenericNamedPropertySetterCallback structPropertySetter);
-    static v8::Local<v8::Value> Invoke(v8::Local<v8::Context> context, Class klass, v8::Local<v8::Object> receiver, V8Args& args, const MethodMeta* meta, bool isMethodCallback);
-    static v8::Local<v8::Value> ConvertArgument(v8::Local<v8::Context> context, BaseDataWrapper* wrapper, bool skipGCRegistration = false, const std::vector<std::string>& additionalProtocols = std::vector<std::string>());
-    static v8::Local<v8::Value> CreateJsWrapper(v8::Local<v8::Context> context, BaseDataWrapper* wrapper, v8::Local<v8::Object> receiver, bool skipGCRegistration = false, const std::vector<std::string>& additionalProtocols = std::vector<std::string>());
-    static std::shared_ptr<v8::Persistent<v8::Value>> CreateEmptyObject(v8::Local<v8::Context> context, bool skipGCRegistration = false);
-    static std::shared_ptr<v8::Persistent<v8::Value>> CreateEmptyStruct(v8::Local<v8::Context> context);
-    static const Meta* FindMeta(Class klass, const TypeEncoding* typeEncoding = nullptr);
-    static const Meta* GetMeta(std::string name);
-    static const ProtocolMeta* FindProtocolMeta(Protocol* protocol);
-    static void MethodCallback(ffi_cif* cif, void* retValue, void** argValues, void* userData);
-    static void SetValue(v8::Local<v8::Context> context, void* retValue, v8::Local<v8::Value> value, const TypeEncoding* typeEncoding);
-    static void ConstructObject(v8::Local<v8::Context> context, const v8::FunctionCallbackInfo<v8::Value>& info, Class klass, const InterfaceMeta* interfaceMeta = nullptr);
-private:
-    static v8::Local<v8::Function> CreateEmptyInstanceFunction(v8::Local<v8::Context> context, v8::GenericNamedPropertyGetterCallback propertyGetter = nullptr, v8::GenericNamedPropertySetterCallback propertySetter = nullptr);
-    static std::shared_ptr<v8::Persistent<v8::Value>> CreateEmptyInstance(v8::Local<v8::Context> context, v8::Persistent<v8::Function>* ctorFunc, bool skipGCRegistration = false);
-    static void FindMethodOverloads(Class klass, std::string methodName, MemberType type, std::vector<const MethodMeta*>& overloads);
-    static const MethodMeta* FindInitializer(v8::Local<v8::Context> context, Class klass, const InterfaceMeta* interfaceMeta, const v8::FunctionCallbackInfo<v8::Value>& info, std::vector<v8::Local<v8::Value>>& args);
-    static bool CanInvoke(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, v8::Local<v8::Value> arg);
-    static bool CanInvoke(v8::Local<v8::Context> context, const MethodMeta* candidate, const v8::FunctionCallbackInfo<v8::Value>& info);
-    static std::vector<v8::Local<v8::Value>> GetInitializerArgs(v8::Local<v8::Object> obj, std::string& constructorTokens);
-    static void IndexedPropertyGetterCallback(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& args);
-    static void IndexedPropertySetterCallback(uint32_t index, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& args);
-    static bool IsErrorOutParameter(const TypeEncoding* typeEncoding);
-    static std::vector<const MethodMeta*> GetInitializers(Caches* cache, Class klass, const InterfaceMeta* interfaceMeta);
-    static void MethodCallbackInternal(ffi_cif* cif, void* retValue, void** argValues, void* userData);
+ public:
+  static void Init(v8::Local<v8::Context> context,
+                   v8::GenericNamedPropertyGetterCallback structPropertyGetter,
+                   v8::GenericNamedPropertySetterCallback structPropertySetter);
+  static v8::Local<v8::Value> Invoke(v8::Local<v8::Context> context,
+                                     Class klass,
+                                     v8::Local<v8::Object> receiver,
+                                     V8Args& args, const MethodMeta* meta,
+                                     bool isMethodCallback);
+  static v8::Local<v8::Value> ConvertArgument(
+      v8::Local<v8::Context> context, BaseDataWrapper* wrapper,
+      bool skipGCRegistration = false,
+      const std::vector<std::string>& additionalProtocols =
+          std::vector<std::string>());
+  static v8::Local<v8::Value> CreateJsWrapper(
+      v8::Local<v8::Context> context, BaseDataWrapper* wrapper,
+      v8::Local<v8::Object> receiver, bool skipGCRegistration = false,
+      const std::vector<std::string>& additionalProtocols =
+          std::vector<std::string>());
+  static std::shared_ptr<v8::Persistent<v8::Value>> CreateEmptyObject(
+      v8::Local<v8::Context> context, bool skipGCRegistration = false);
+  static std::shared_ptr<v8::Persistent<v8::Value>> CreateEmptyStruct(
+      v8::Local<v8::Context> context);
+  static const Meta* FindMeta(Class klass,
+                              const TypeEncoding* typeEncoding = nullptr);
+  static const Meta* GetMeta(std::string name);
+  static const ProtocolMeta* FindProtocolMeta(Protocol* protocol);
+  static void MethodCallback(ffi_cif* cif, void* retValue, void** argValues,
+                             void* userData);
+  static void SetValue(v8::Local<v8::Context> context, void* retValue,
+                       v8::Local<v8::Value> value,
+                       const TypeEncoding* typeEncoding);
+  // Returns (lazily creating) the per-isolate interop.escapeException brand
+  // private stored in Caches. Empty handle if the isolate cache is invalid.
+  static v8::Local<v8::Private> GetEscapeExceptionBrand(v8::Isolate* isolate);
+  // If `value` carries the escapeException brand, returns the NSException to
+  // throw (typed `id` so this header is usable from the pure-C++ TUs that
+  // include it) — the original wrapped NSException when present, otherwise one
+  // synthesized from the branded name/message/stack payload. Returns nil when
+  // `value` is not branded. Never reports; the caller decides what to do.
+  static id ExtractEscapedException(v8::Local<v8::Context> context,
+                                    v8::Local<v8::Value> value);
+  // Shared JS<->native boundary helper. Reads tc.Exception(): if it carries
+  // the escapeException brand, returns the NSException (as `id`) the caller
+  // must @throw AFTER closing every live V8 scope (Locker/HandleScope/
+  // Context::Scope). Otherwise reports the exception exactly once through the
+  // uncaught path (error-event dispatch + shims + log) and returns nil, so the
+  // caller returns its defined default. Resets `tc` in both cases.
+  static id HandleBoundaryException(v8::Local<v8::Context> context,
+                                    v8::TryCatch& tc);
+  static void ConstructObject(v8::Local<v8::Context> context,
+                              const v8::FunctionCallbackInfo<v8::Value>& info,
+                              Class klass,
+                              const InterfaceMeta* interfaceMeta = nullptr);
+
+ private:
+  static v8::Local<v8::Function> CreateEmptyInstanceFunction(
+      v8::Local<v8::Context> context,
+      v8::GenericNamedPropertyGetterCallback propertyGetter = nullptr,
+      v8::GenericNamedPropertySetterCallback propertySetter = nullptr);
+  static std::shared_ptr<v8::Persistent<v8::Value>> CreateEmptyInstance(
+      v8::Local<v8::Context> context, v8::Persistent<v8::Function>* ctorFunc,
+      bool skipGCRegistration = false);
+  static void FindMethodOverloads(Class klass, std::string methodName,
+                                  MemberType type,
+                                  std::vector<const MethodMeta*>& overloads);
+  static const MethodMeta* FindInitializer(
+      v8::Local<v8::Context> context, Class klass,
+      const InterfaceMeta* interfaceMeta,
+      const v8::FunctionCallbackInfo<v8::Value>& info,
+      std::vector<v8::Local<v8::Value>>& args);
+  static bool CanInvoke(v8::Local<v8::Context> context,
+                        const TypeEncoding* typeEncoding,
+                        v8::Local<v8::Value> arg);
+  static bool CanInvoke(v8::Local<v8::Context> context,
+                        const MethodMeta* candidate,
+                        const v8::FunctionCallbackInfo<v8::Value>& info);
+  static std::vector<v8::Local<v8::Value>> GetInitializerArgs(
+      v8::Local<v8::Object> obj, std::string& constructorTokens);
+  static void IndexedPropertyGetterCallback(
+      uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& args);
+  static void IndexedPropertySetterCallback(
+      uint32_t index, v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static bool IsErrorOutParameter(const TypeEncoding* typeEncoding);
+  static std::vector<const MethodMeta*> GetInitializers(
+      Caches* cache, Class klass, const InterfaceMeta* interfaceMeta);
+  static void MethodCallbackInternal(ffi_cif* cif, void* retValue,
+                                     void** argValues, void* userData);
 };
 
-}
+}  // namespace tns
 
 #endif /* ArgConverter_h */
diff --git a/NativeScript/runtime/ArgConverter.mm b/NativeScript/runtime/ArgConverter.mm
index 2197c820..8c21f036 100644
--- a/NativeScript/runtime/ArgConverter.mm
+++ b/NativeScript/runtime/ArgConverter.mm
@@ -4,6 +4,7 @@
 #include "DictionaryAdapter.h"
 #include "Helpers.h"
 #include "Interop.h"
+#include "NSExceptionSupport.h"
 #include "NativeScriptException.h"
 #include "ObjectManager.h"
 #include "Runtime.h"
@@ -128,6 +129,149 @@
   return result;
 }
 
+Local<Private> ArgConverter::GetEscapeExceptionBrand(Isolate* isolate) {
+  auto cache = Caches::Get(isolate);
+  // Caches::Get never returns null — after isolate removal it returns a dummy
+  // cache — so validity is the real liveness check before touching V8 state.
+  if (cache == nullptr || !cache->IsValid()) {
+    return Local<Private>();
+  }
+  if (cache->EscapeExceptionBrand == nullptr) {
+    Local<Private> brand =
+        Private::New(isolate, tns::ToV8String(isolate, "interop.escapeException"));
+    cache->EscapeExceptionBrand = std::make_unique<Persistent<Private>>(isolate, brand);
+  }
+  return cache->EscapeExceptionBrand->Get(isolate);
+}
+
+// Builds the combined JS stack string attached to an escaped exception via the
+// associated object: the origin (propagation) stack of the wrapping error and
+// the escape-site stack, each under a labeled section. Empty or duplicate
+// sections are omitted; returns nil when nothing is available.
+static NSString* BuildCombinedJSStack(const std::string& origin, const std::string& escape) {
+  NSMutableArray<NSString*>* parts = [NSMutableArray array];
+  if (!origin.empty()) {
+    [parts addObject:[NSString stringWithFormat:@"JS stack:\n%@", tns::ToNSString(origin)]];
+  }
+  if (!escape.empty() && escape != origin) {
+    [parts addObject:[NSString stringWithFormat:@"Escaped at:\n%@", tns::ToNSString(escape)]];
+  }
+  if (parts.count == 0) {
+    return nil;
+  }
+  return [parts componentsJoinedByString:@"\n\n"];
+}
+
+id ArgConverter::ExtractEscapedException(Local<Context> context, Local<Value> value) {
+  Isolate* isolate = context->GetIsolate();
+  if (value.IsEmpty() || !value->IsObject()) {
+    return nil;
+  }
+  Local<Private> brand = GetEscapeExceptionBrand(isolate);
+  if (brand.IsEmpty()) {
+    return nil;
+  }
+  Local<Object> obj = value.As<Object>();
+  Maybe<bool> hasBrand = obj->HasPrivate(context, brand);
+  if (hasBrand.IsNothing() || !hasBrand.FromJust()) {
+    return nil;
+  }
+  Local<Value> payloadVal;
+  if (!obj->GetPrivate(context, brand).ToLocal(&payloadVal) || !payloadVal->IsObject()) {
+    return nil;
+  }
+  Local<Object> payload = payloadVal.As<Object>();
+
+  auto readString = [&](const char* key, const std::string& fallback) -> std::string {
+    Local<Value> v;
+    if (payload->Get(context, tns::ToV8String(isolate, key)).ToLocal(&v) && !v.IsEmpty() &&
+        v->IsString()) {
+      return tns::ToString(isolate, v);
+    }
+    return fallback;
+  };
+
+  // The escape-site stack always travels with the payload; the origin stack is
+  // the wrapping error's own `.stack`, carried when present.
+  std::string escapeStack = readString("escapeStack", "");
+
+  // Original NSException carried through unchanged when present.
+  Local<Value> nativeExc;
+  if (payload->Get(context, tns::ToV8String(isolate, "nativeException")).ToLocal(&nativeExc) &&
+      nativeExc->IsObject()) {
+    BaseDataWrapper* wrapper = tns::GetValue(isolate, nativeExc);
+    if (wrapper != nullptr && wrapper->Type() == WrapperType::ObjCObject) {
+      id data = static_cast<ObjCDataWrapper*>(wrapper)->Data();
+      if ([data isKindOfClass:[NSException class]]) {
+        // Attach the JS stack WITHOUT mutating the original exception's identity
+        // or userInfo — the round-trip contract requires the very same object to
+        // reach the native @catch. The category accessor surfaces it uniformly.
+        std::string originStack = readString("stack", "");
+        NSString* combined = BuildCombinedJSStack(originStack, escapeStack);
+        if (combined != nil) {
+          tns::SetJSStackOnException((NSException*)data, combined);
+        }
+        return (NSException*)data;
+      }
+    }
+  }
+
+  // Otherwise synthesize an NSException from the branded name/message/stack.
+  std::string name = readString("name", "NativeScriptException");
+  std::string message = readString("message", "");
+  std::string stack = readString("stack", "");
+
+  NSString* reasonText = tns::ToNSString(message);
+  if (!stack.empty()) {
+    // Put the JS stack in the reason too so it shows up in native crash logs.
+    reasonText = [reasonText stringByAppendingFormat:@"\n%@", tns::ToNSString(stack)];
+  }
+  NSMutableDictionary* userInfo = [NSMutableDictionary dictionary];
+  if (!stack.empty()) {
+    userInfo[TNSJavaScriptStackTraceKey] = tns::ToNSString(stack);
+  }
+  // Carry the escape-site stack separately only when it adds information beyond
+  // the origin stack.
+  if (!escapeStack.empty() && escapeStack != stack) {
+    userInfo[TNSJavaScriptEscapeStackTraceKey] = tns::ToNSString(escapeStack);
+  }
+  NSException* synthesized = [NSException exceptionWithName:tns::ToNSString(name)
+                                                     reason:reasonText
+                                                   userInfo:userInfo.count ? userInfo : nil];
+  // Attach the combined stack via associated object so the category accessor is
+  // uniform across synthesized and rethrown-original exceptions.
+  NSString* combined = BuildCombinedJSStack(stack, escapeStack);
+  if (combined != nil) {
+    tns::SetJSStackOnException(synthesized, combined);
+  }
+  return synthesized;
+}
+
+id ArgConverter::HandleBoundaryException(Local<Context> context, TryCatch& tc) {
+  if (!tc.HasCaught()) {
+    return nil;
+  }
+  Isolate* isolate = context->GetIsolate();
+  Local<Value> exception = tc.Exception();
+
+  id escaped = ExtractEscapedException(context, exception);
+  if (escaped != nil) {
+    // Branded escape: convert to an ObjC throw. Clear the V8 exception; the
+    // caller @throws this AFTER closing all V8 scopes.
+    tc.Reset();
+    return escaped;
+  }
+
+  // Unbranded: report exactly once through the uncaught path (error-event
+  // dispatch + shims + log; honors crashOnUncaughtJsExceptions). This is the
+  // path for the Assert-hardened sites that today never reach the message
+  // listener at all.
+  Local<v8::Message> message = tc.Message();
+  NativeScriptException::ReportToJsHandlersAndLog(isolate, exception, message);
+  tc.Reset();
+  return nil;
+}
+
 void ArgConverter::MethodCallback(ffi_cif* cif, void* retValue, void** argValues, void* userData) {
   MethodCallbackWrapper* data = static_cast<MethodCallbackWrapper*>(userData);
 
@@ -138,90 +282,123 @@
     return;
   }
 
-  v8::Locker locker(isolate);
-  Isolate::Scope isolate_scope(isolate);
-  HandleScope handle_scope(isolate);
-  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  // Declared before all V8 scopes: an ObjC exception must never unwind through a
+  // live V8 scope (Locker/HandleScope/Context::Scope). A branded escape caught
+  // below is captured here and @thrown only after the inner block closes every
+  // V8 scope.
+  NSException* __strong pendingThrow = nil;
 
-  Local<Context> context = cache->GetContext();
-  Context::Scope context_scope(context);
-  std::shared_ptr<Persistent<Value>> poCallback = data->callback_;
+  {
+    v8::Locker locker(isolate);
+    Isolate::Scope isolate_scope(isolate);
+    HandleScope handle_scope(isolate);
+    std::shared_ptr<Caches> cache = Caches::Get(isolate);
 
-  bool hasErrorOutParameter = false;
+    Local<Context> context = cache->GetContext();
+    Context::Scope context_scope(context);
+    std::shared_ptr<Persistent<Value>> poCallback = data->callback_;
+
+    bool hasErrorOutParameter = false;
+
+    std::vector<Local<Value>> v8Args;
+    v8Args.reserve(data->paramsCount_);
+    const TypeEncoding* typeEncoding = data->typeEncoding_;
+    for (int i = 0; i < data->paramsCount_; i++) {
+      typeEncoding = typeEncoding->next();
+      if (i == data->paramsCount_ - 1 && ArgConverter::IsErrorOutParameter(typeEncoding)) {
+        hasErrorOutParameter = true;
+        // No need to provide the NSError** parameter to the javascript callback
+        continue;
+      }
 
-  std::vector<Local<Value>> v8Args;
-  v8Args.reserve(data->paramsCount_);
-  const TypeEncoding* typeEncoding = data->typeEncoding_;
-  for (int i = 0; i < data->paramsCount_; i++) {
-    typeEncoding = typeEncoding->next();
-    if (i == data->paramsCount_ - 1 && ArgConverter::IsErrorOutParameter(typeEncoding)) {
-      hasErrorOutParameter = true;
-      // No need to provide the NSError** parameter to the javascript callback
-      continue;
-    }
+      int argIndex = i + data->initialParamIndex_;
 
-    int argIndex = i + data->initialParamIndex_;
+      uint8_t* argBuffer = (uint8_t*)argValues[argIndex];
+      BaseCall call(argBuffer);
+      Local<Value> jsWrapper = Interop::GetResult(context, typeEncoding, &call, true);
 
-    uint8_t* argBuffer = (uint8_t*)argValues[argIndex];
-    BaseCall call(argBuffer);
-    Local<Value> jsWrapper = Interop::GetResult(context, typeEncoding, &call, true);
+      if (!jsWrapper.IsEmpty()) {
+        v8Args.push_back(jsWrapper);
+      } else {
+        v8Args.push_back(v8::Undefined(isolate));
+      }
+    }
 
-    if (!jsWrapper.IsEmpty()) {
-      v8Args.push_back(jsWrapper);
-    } else {
-      v8Args.push_back(v8::Undefined(isolate));
+    Local<Object> thiz = context->Global();
+    if (data->initialParamIndex_ > 1) {
+      id self_ = *static_cast<const id*>(argValues[0]);
+      auto it = cache->Instances.find(self_);
+      if (it != cache->Instances.end()) {
+        thiz = it->second->Get(data->isolateWrapper_.Isolate()).As<Object>();
+      } else {
+        ObjCDataWrapper* wrapper = new ObjCDataWrapper(self_);
+        thiz = ArgConverter::CreateJsWrapper(context, wrapper, Local<Object>(), true).As<Object>();
+        tns::DeleteWrapperIfUnused(isolate, thiz, wrapper);
+      }
     }
-  }
 
-  Local<Object> thiz = context->Global();
-  if (data->initialParamIndex_ > 1) {
-    id self_ = *static_cast<const id*>(argValues[0]);
-    auto it = cache->Instances.find(self_);
-    if (it != cache->Instances.end()) {
-      thiz = it->second->Get(data->isolateWrapper_.Isolate()).As<Object>();
+    Local<Value> result;
+    Local<v8::Function> callback = poCallback->Get(isolate).As<v8::Function>();
+
+    bool success = false;
+    if (hasErrorOutParameter) {
+      // We don't want the global error handler (NativeScriptException::OnUncaughtError) to be
+      // called for javascript exceptions occuring inside methods that have NSError* parameters.
+      // Those js errors will be marshalled to NSError* and sent directly to the calling native
+      // code. The v8::TryCatch statement prevents the global handler to be called.
+      TryCatch tc(isolate);
+      success = callback->Call(context, thiz, (int)v8Args.size(), v8Args.data()).ToLocal(&result);
+      if (!success && tc.HasCaught()) {
+        // A branded escapeException follows the @throw path even here, taking
+        // precedence over NSError-out marshaling.
+        NSException* escaped = ExtractEscapedException(context, tc.Exception());
+        if (escaped != nil) {
+          pendingThrow = escaped;
+        } else {
+          Local<Value> exception = tc.Exception();
+          std::string message = tns::ToString(isolate, exception);
+
+          int errorParamIndex = data->initialParamIndex_ + data->paramsCount_ - 1;
+          void* errorParam = argValues[errorParamIndex];
+          NSError* __strong** outPtr = static_cast<NSError * __strong**>(errorParam);
+          if (outPtr && *outPtr) {
+            NSError* error =
+                [NSError errorWithDomain:@"TNSErrorDomain"
+                                    code:164
+                                userInfo:@{@"TNSJavaScriptError" : tns::ToNSString(message)}];
+            **static_cast<NSError * __strong**>(outPtr) = error;
+          }
+        }
+      }
     } else {
-      ObjCDataWrapper* wrapper = new ObjCDataWrapper(self_);
-      thiz = ArgConverter::CreateJsWrapper(context, wrapper, Local<Object>(), true).As<Object>();
-      tns::DeleteWrapperIfUnused(isolate, thiz, wrapper);
+      TryCatch tc(isolate);
+      success = callback->Call(context, thiz, (int)v8Args.size(), v8Args.data()).ToLocal(&result);
+      if (!success && tc.HasCaught()) {
+        NSException* escaped = ExtractEscapedException(context, tc.Exception());
+        if (escaped != nil) {
+          pendingThrow = escaped;
+        } else {
+          // Unbranded: re-throw so the pending exception surfaces to V8's message
+          // listener exactly once (OnUncaughtError), preserving existing behavior.
+          tc.ReThrow();
+        }
+      }
     }
-  }
 
-  Local<Value> result;
-  Local<v8::Function> callback = poCallback->Get(isolate).As<v8::Function>();
-
-  bool success = false;
-  if (hasErrorOutParameter) {
-    // We don't want the global error handler (NativeScriptException::OnUncaughtError) to be called
-    // for javascript exceptions occuring inside methods that have NSError* parameters. Those js
-    // errors will be marshalled to NSError* and sent directly to the calling native code. The
-    // v8::TryCatch statement prevents the global handler to be called.
-    TryCatch tc(isolate);
-    success = callback->Call(context, thiz, (int)v8Args.size(), v8Args.data()).ToLocal(&result);
-    if (!success && tc.HasCaught()) {
-      Local<Value> exception = tc.Exception();
-      std::string message = tns::ToString(isolate, exception);
-
-      int errorParamIndex = data->initialParamIndex_ + data->paramsCount_ - 1;
-      void* errorParam = argValues[errorParamIndex];
-      NSError* __strong** outPtr = static_cast<NSError * __strong**>(errorParam);
-      if (outPtr && *outPtr) {
-        NSError* error =
-            [NSError errorWithDomain:@"TNSErrorDomain"
-                                code:164
-                            userInfo:@{@"TNSJavaScriptError" : tns::ToNSString(message)}];
-        **static_cast<NSError * __strong**>(outPtr) = error;
+    if (pendingThrow == nil) {
+      if (!success) {
+        memset(retValue, 0, cif->rtype->size);
+      } else {
+        ArgConverter::SetValue(context, retValue, result, data->typeEncoding_);
       }
+    } else {
+      memset(retValue, 0, cif->rtype->size);
     }
-  } else {
-    success = callback->Call(context, thiz, (int)v8Args.size(), v8Args.data()).ToLocal(&result);
-  }
+  }  // all V8 scopes destruct here
 
-  if (!success) {
-    memset(retValue, 0, cif->rtype->size);
-    return;
+  if (pendingThrow != nil) {
+    @throw pendingThrow;
   }
-
-  ArgConverter::SetValue(context, retValue, result, data->typeEncoding_);
 }
 
 void ArgConverter::SetValue(Local<Context> context, void* retValue, Local<Value> value,
diff --git a/NativeScript/runtime/ArrayAdapter.mm b/NativeScript/runtime/ArrayAdapter.mm
index 2dfba4ec..ed7d10f3 100644
--- a/NativeScript/runtime/ArrayAdapter.mm
+++ b/NativeScript/runtime/ArrayAdapter.mm
@@ -1,4 +1,5 @@
 #include "ArrayAdapter.h"
+#include "ArgConverter.h"
 #include "DataWrapper.h"
 #include "Helpers.h"
 #include "Interop.h"
@@ -8,99 +9,123 @@
 using namespace v8;
 
 @implementation ArrayAdapter {
-    IsolateWrapper* wrapper_;
-    std::shared_ptr<Persistent<Value>> object_;
-    // we're responsible for this wrapper
-    ObjCDataWrapper* dataWrapper_;
+  IsolateWrapper* wrapper_;
+  std::shared_ptr<Persistent<Value>> object_;
+  // we're responsible for this wrapper
+  ObjCDataWrapper* dataWrapper_;
 }
 
 - (instancetype)initWithJSObject:(Local<Object>)jsObject isolate:(Isolate*)isolate {
-    if (self) {
-        self->wrapper_ = new IsolateWrapper(isolate);
-        self->object_ = std::make_shared<Persistent<Value>>(isolate, jsObject);
-        self->wrapper_->GetCache()->Instances.emplace(self, self->object_);
-        tns::SetValue(isolate, jsObject, (self->dataWrapper_ = new ObjCDataWrapper(self)));
-    }
-    
-    return self;
+  if (self) {
+    self->wrapper_ = new IsolateWrapper(isolate);
+    self->object_ = std::make_shared<Persistent<Value>>(isolate, jsObject);
+    self->wrapper_->GetCache()->Instances.emplace(self, self->object_);
+    tns::SetValue(isolate, jsObject, (self->dataWrapper_ = new ObjCDataWrapper(self)));
+  }
+
+  return self;
 }
 
 - (NSUInteger)count {
-    auto isolate = wrapper_->Isolate();
-    if(!wrapper_->IsValid()) {
-        return 0;
-    }
+  auto isolate = wrapper_->Isolate();
+  if (!wrapper_->IsValid()) {
+    return 0;
+  }
+  NSUInteger result = 0;
+  // Scopes-before-@throw: a branded escape from the JS boundary is @thrown only
+  // after the inner block's V8 scopes destruct.
+  NSException* __strong pendingThrow = nil;
+  {
     v8::Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
-    
+
     Local<Object> object = self->object_->Get(isolate).As<Object>();
     if (object->IsArray()) {
-        uint32_t length = object.As<v8::Array>()->Length();
-        return length;
+      result = object.As<v8::Array>()->Length();
+    } else {
+      Local<Context> context = wrapper_->GetCache()->GetContext();
+      Local<v8::Array> propertyNames;
+      TryCatch tc(isolate);
+      if (object->GetPropertyNames(context).ToLocal(&propertyNames)) {
+        result = propertyNames->Length();
+      } else {
+        NSException* ex = ArgConverter::HandleBoundaryException(context, tc);
+        if (ex != nil) {
+          pendingThrow = ex;
+        }
+      }
     }
-    
-    Local<Context> context = wrapper_->GetCache()->GetContext();
-    Local<v8::Array> propertyNames;
-    bool success = object->GetPropertyNames(context).ToLocal(&propertyNames);
-    tns::Assert(success, isolate);
-    uint32_t length = propertyNames->Length();
-    return length;
+  }
+  if (pendingThrow != nil) {
+    @throw pendingThrow;
+  }
+  return result;
 }
 
 - (id)objectAtIndex:(NSUInteger)index {
-    auto isolate = wrapper_->Isolate();
-    if (!wrapper_->IsValid()) {
-        return nil;
-    }
+  auto isolate = wrapper_->Isolate();
+  if (!wrapper_->IsValid()) {
+    return nil;
+  }
+
+  if (!(index < [self count])) {
+    // Out of bounds: return the adapter default rather than aborting.
+    return nil;
+  }
+
+  id result = nil;
+  NSException* __strong pendingThrow = nil;
+  {
     v8::Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
-    
-    if (!(index < [self count])) {
-        tns::Assert(false, isolate);
-    }
-    
+
     Local<Object> object = self->object_->Get(isolate).As<Object>();
     Local<Context> context = wrapper_->GetCache()->GetContext();
     Local<Value> item;
-    bool success = object->Get(context, (uint)index).ToLocal(&item);
-    tns::Assert(success, isolate);
-    
-    if (item->IsNullOrUndefined()) {
-        return nil;
+    TryCatch tc(isolate);
+    if (!object->Get(context, (uint)index).ToLocal(&item)) {
+      NSException* ex = ArgConverter::HandleBoundaryException(context, tc);
+      if (ex != nil) {
+        pendingThrow = ex;
+      }
+    } else if (!item->IsNullOrUndefined()) {
+      result = Interop::ToObject(context, item);
     }
-
-    id value = Interop::ToObject(context, item);
-    return value;
+  }
+  if (pendingThrow != nil) {
+    @throw pendingThrow;
+  }
+  return result;
 }
 
 - (void)dealloc {
-    if (wrapper_->IsValid()) {
-        auto isolate = wrapper_->Isolate();
-        v8::Locker locker(isolate);
-        Isolate::Scope isolate_scope(isolate);
-        HandleScope handle_scope(isolate);
-        wrapper_->GetCache()->Instances.erase(self);
-        Local<Value> value = self->object_->Get(isolate);
-        BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
-        if (wrapper != nullptr) {
-            tns::DeleteValue(isolate, value);
-            // ensure we don't delete the same wrapper twice
-            // this is just needed as a failsafe in case some other wrapper is assigned to this object
-            if (wrapper == dataWrapper_) {
-                dataWrapper_ = nullptr;
-            }
-            delete wrapper;
-        }
-        self->object_->Reset();
-    }
-    delete wrapper_;
-    if (dataWrapper_ != nullptr) {
-        delete dataWrapper_;
+  if (wrapper_->IsValid()) {
+    auto isolate = wrapper_->Isolate();
+    v8::Locker locker(isolate);
+    Isolate::Scope isolate_scope(isolate);
+    HandleScope handle_scope(isolate);
+    wrapper_->GetCache()->Instances.erase(self);
+    Local<Value> value = self->object_->Get(isolate);
+    BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
+    if (wrapper != nullptr) {
+      tns::DeleteValue(isolate, value);
+      // ensure we don't delete the same wrapper twice
+      // this is just needed as a failsafe in case some other wrapper is assigned to this object
+      if (wrapper == dataWrapper_) {
+        dataWrapper_ = nullptr;
+      }
+      delete wrapper;
     }
-    self->object_ = nullptr;
-    [super dealloc];
+    self->object_->Reset();
+  }
+  delete wrapper_;
+  if (dataWrapper_ != nullptr) {
+    delete dataWrapper_;
+  }
+  self->object_ = nullptr;
+  [super dealloc];
 }
 
 @end
diff --git a/NativeScript/runtime/BuiltinLoader.cpp b/NativeScript/runtime/BuiltinLoader.cpp
new file mode 100644
index 00000000..4df99109
--- /dev/null
+++ b/NativeScript/runtime/BuiltinLoader.cpp
@@ -0,0 +1,83 @@
+#include "BuiltinLoader.h"
+
+#include <mutex>
+#include <vector>
+
+#include "Helpers.h"
+
+using namespace v8;
+
+namespace tns {
+
+namespace {
+
+// Process-wide bytecode cache shared across isolates (main + workers).
+std::mutex builtinCacheMutex;
+std::vector<uint8_t> builtinCache[static_cast<unsigned>(BuiltinId::kCount)];
+
+}  // namespace
+
+MaybeLocal<Value> BuiltinLoader::RunBuiltin(Local<Context> context,
+                                            BuiltinId id) {
+  Isolate* isolate = context->GetIsolate();
+  const BuiltinSource& builtin = GetBuiltinSource(id);
+  const unsigned index = static_cast<unsigned>(id);
+
+  // Copy the blob out so the shared slot can be refreshed concurrently while
+  // this compile still reads from the copy.
+  std::vector<uint8_t> blob;
+  {
+    std::lock_guard<std::mutex> lock(builtinCacheMutex);
+    blob = builtinCache[index];
+  }
+
+  ScriptOrigin origin(isolate, tns::ToV8String(isolate, builtin.name),
+                      0,      // line offset
+                      0,      // column offset
+                      false,  // shared_cross_origin
+                      -1,     // script_id
+                      Local<Value>(),
+                      false,  // is_opaque
+                      false,  // is_wasm
+                      false   // is_module
+  );
+  Local<v8::String> sourceText = tns::ToV8String(
+      isolate, builtin.source, static_cast<int>(builtin.length));
+
+  Local<Script> script;
+  if (!blob.empty()) {
+    // The Source owns and deletes the CachedData object; BufferNotOwned keeps
+    // the underlying bytes (our copy) out of its hands.
+    auto* cachedData = new ScriptCompiler::CachedData(
+        blob.data(), static_cast<int>(blob.size()),
+        ScriptCompiler::CachedData::BufferNotOwned);
+    ScriptCompiler::Source source(sourceText, origin, cachedData);
+    if (ScriptCompiler::Compile(context, &source,
+                                ScriptCompiler::kConsumeCodeCache)
+            .ToLocal(&script) &&
+        !cachedData->rejected) {
+      return script->Run(context);
+    }
+    // Rejected cache (e.g. produced under different flags): fall through and
+    // recompile eagerly so the refreshed blob covers inner functions again.
+  }
+
+  ScriptCompiler::Source source(sourceText, origin);
+  if (!ScriptCompiler::Compile(context, &source, ScriptCompiler::kEagerCompile)
+           .ToLocal(&script)) {
+    return MaybeLocal<Value>();
+  }
+
+  std::unique_ptr<ScriptCompiler::CachedData> produced(
+      ScriptCompiler::CreateCodeCache(script->GetUnboundScript()));
+  if (produced != nullptr && produced->data != nullptr &&
+      produced->length > 0) {
+    std::lock_guard<std::mutex> lock(builtinCacheMutex);
+    builtinCache[index].assign(produced->data,
+                               produced->data + produced->length);
+  }
+
+  return script->Run(context);
+}
+
+}  // namespace tns
diff --git a/NativeScript/runtime/BuiltinLoader.h b/NativeScript/runtime/BuiltinLoader.h
new file mode 100644
index 00000000..e1a804a5
--- /dev/null
+++ b/NativeScript/runtime/BuiltinLoader.h
@@ -0,0 +1,23 @@
+#ifndef BuiltinLoader_h
+#define BuiltinLoader_h
+
+#include "Common.h"
+#include "RuntimeBuiltins.h"
+
+namespace tns {
+
+class BuiltinLoader {
+ public:
+  // Compiles and runs the builtin script identified by id in the given context
+  // and returns its completion value. Scripts carry an "internal/<name>.js"
+  // origin so runtime frames are identifiable in stack traces. Compilation goes
+  // through a process-wide bytecode cache: the first run in the process
+  // compiles eagerly and populates the cache, later isolates (workers) consume
+  // it instead of re-parsing the source.
+  static v8::MaybeLocal<v8::Value> RunBuiltin(v8::Local<v8::Context> context,
+                                              BuiltinId id);
+};
+
+}  // namespace tns
+
+#endif /* BuiltinLoader_h */
diff --git a/NativeScript/runtime/Caches.cpp b/NativeScript/runtime/Caches.cpp
index 9810625f..3cff2d29 100644
--- a/NativeScript/runtime/Caches.cpp
+++ b/NativeScript/runtime/Caches.cpp
@@ -1,47 +1,54 @@
 #include "Caches.h"
+
 #include "Constants.h"
+#include "NativeScriptException.h"
 
 using namespace v8;
 
 namespace tns {
 
 Caches::Caches(Isolate* isolate, const int& isolateId)
-    : isolate_(isolate), isolateId_(isolateId) {
-}
+    : PromiseRejections(std::make_unique<PromiseRejectionTracker>(isolate)),
+      isolate_(isolate),
+      isolateId_(isolateId) {}
 
 Caches::~Caches() {
-    this->Prototypes.clear();
-    this->ClassPrototypes.clear();
-    this->CtorFuncTemplates.clear();
-    this->CtorFuncs.clear();
-    this->ProtocolCtorFuncs.clear();
-    this->StructConstructorFunctions.clear();
-    this->PrimitiveInteropTypes.clear();
-    this->CFunctions.clear();
-
-    this->Instances.clear();
-    this->StructInstances.clear();
-    this->PointerInstances.clear();
-    this->cacheBoundObjects_.clear();
+  this->Prototypes.clear();
+  this->ClassPrototypes.clear();
+  this->CtorFuncTemplates.clear();
+  this->CtorFuncs.clear();
+  this->ProtocolCtorFuncs.clear();
+  this->StructConstructorFunctions.clear();
+  this->PrimitiveInteropTypes.clear();
+  this->CFunctions.clear();
+
+  this->Instances.clear();
+  this->StructInstances.clear();
+  this->PointerInstances.clear();
+  this->cacheBoundObjects_.clear();
 }
 
 void Caches::Remove(v8::Isolate* isolate) {
-    auto cache = isolate->GetData(Constants::CACHES_ISOLATE_SLOT);
-    isolate->SetData(Constants::CACHES_ISOLATE_SLOT, nullptr);
-    if (cache != nullptr) {
-        delete reinterpret_cast<std::shared_ptr<Caches>*>(cache);
-    }
+  auto cache = isolate->GetData(Constants::CACHES_ISOLATE_SLOT);
+  isolate->SetData(Constants::CACHES_ISOLATE_SLOT, nullptr);
+  if (cache != nullptr) {
+    delete reinterpret_cast<std::shared_ptr<Caches>*>(cache);
+  }
 }
 
 void Caches::SetContext(Local<Context> context) {
-    this->context_ = std::make_shared<Persistent<Context>>(this->isolate_, context);
+  this->context_ =
+      std::make_shared<Persistent<Context>>(this->isolate_, context);
 }
 
 Local<Context> Caches::GetContext() {
-    return this->context_->Get(this->isolate_);
+  return this->context_->Get(this->isolate_);
 }
 
-std::shared_ptr<ConcurrentMap<std::string, const Meta*>> Caches::Metadata = std::make_shared<ConcurrentMap<std::string, const Meta*>>();
-std::shared_ptr<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>> Caches::Workers = std::make_shared<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>>();
+std::shared_ptr<ConcurrentMap<std::string, const Meta*>> Caches::Metadata =
+    std::make_shared<ConcurrentMap<std::string, const Meta*>>();
+std::shared_ptr<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>>
+    Caches::Workers = std::make_shared<
+        ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>>();
 
-}
+}  // namespace tns
diff --git a/NativeScript/runtime/Caches.h b/NativeScript/runtime/Caches.h
index 2126410c..05fb1a79 100644
--- a/NativeScript/runtime/Caches.h
+++ b/NativeScript/runtime/Caches.h
@@ -3,140 +3,207 @@
 
 #include <string>
 #include <vector>
-#include "ConcurrentMap.h"
-#include "robin_hood.h"
+
 #include "Common.h"
+#include "ConcurrentMap.h"
 #include "Metadata.h"
+#include "robin_hood.h"
 
 namespace tns {
 
 struct StructInfo;
+class PromiseRejectionTracker;
 
 struct pair_hash {
-    template <class T1, class T2>
-    std::size_t operator() (const std::pair<T1, T2> &pair) const {
-        return std::hash<T1>()(pair.first) ^ std::hash<T2>()(pair.second);
-    }
+  template <class T1, class T2>
+  std::size_t operator()(const std::pair<T1, T2>& pair) const {
+    return std::hash<T1>()(pair.first) ^ std::hash<T2>()(pair.second);
+  }
 };
 
 class Caches {
-public:
-    class WorkerState {
-    public:
-        WorkerState(v8::Isolate* isolate, std::shared_ptr<v8::Persistent<v8::Value>> poWorker, void* userData)
-        : isolate_(isolate),
-        poWorker_(poWorker),
-        userData_(userData) {
-        }
-
-        v8::Isolate* GetIsolate() {
-            return this->isolate_;
-        }
-
-        std::shared_ptr<v8::Persistent<v8::Value>> GetWorker() {
-            return this->poWorker_;
-        }
-
-        void* UserData() {
-            return this->userData_;
-        }
-    private:
-        v8::Isolate* isolate_;
-        std::shared_ptr<v8::Persistent<v8::Value>> poWorker_;
-        void* userData_;
-    };
-
-    Caches(v8::Isolate* isolate, const int& isolateId_ = -1);
-    ~Caches();
-    
-    bool isWorker = false;
-
-    static std::shared_ptr<ConcurrentMap<std::string, const Meta*>> Metadata;
-    static std::shared_ptr<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>> Workers;
-
-    inline static std::shared_ptr<Caches> Init(v8::Isolate* isolate, const int& isolateId) {
-        auto cache = std::make_shared<Caches>(isolate, isolateId);
-        // create a new shared_ptr that will live until Remove is called
-        isolate->SetData(0, static_cast<void*>(new std::shared_ptr<Caches>(cache)));
-        return cache;
-    }
-    inline static std::shared_ptr<Caches> Get(v8::Isolate* isolate) {
-        auto cache = isolate->GetData(0);
-        if (cache != nullptr) {
-            return *reinterpret_cast<std::shared_ptr<Caches>*>(cache);
-        }
-        // this should only happen when an isolate is accessed after disposal
-        // so we return a dummy cache
-        return std::make_shared<Caches>(isolate);
-    }
-    static void Remove(v8::Isolate* isolate);
-    
-    inline int getIsolateId() {
-        return isolateId_;
-    }
-
-    inline void InvalidateIsolate() {
-        isolateId_ = -1;
+ public:
+  class WorkerState {
+   public:
+    WorkerState(v8::Isolate* isolate,
+                std::shared_ptr<v8::Persistent<v8::Value>> poWorker,
+                void* userData)
+        : isolate_(isolate), poWorker_(poWorker), userData_(userData) {}
+
+    v8::Isolate* GetIsolate() { return this->isolate_; }
+
+    std::shared_ptr<v8::Persistent<v8::Value>> GetWorker() {
+      return this->poWorker_;
     }
 
-    inline bool IsValid() {
-        return isolateId_ != -1;
-    }
+    void* UserData() { return this->userData_; }
 
-    void SetContext(v8::Local<v8::Context> context);
-    v8::Local<v8::Context> GetContext();
-
-    robin_hood::unordered_map<const Meta*, std::unique_ptr<v8::Persistent<v8::Value>>> Prototypes;
-    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Object>>> ClassPrototypes;
-    robin_hood::unordered_map<const BaseClassMeta*, std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>> CtorFuncTemplates;
-    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> CtorFuncs;
-    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> ProtocolCtorFuncs;
-    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> StructConstructorFunctions;
-    robin_hood::unordered_map<BinaryTypeEncodingType, std::unique_ptr<v8::Persistent<v8::Object>>> PrimitiveInteropTypes;
-    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> CFunctions;
-
-    robin_hood::unordered_map<id, std::shared_ptr<v8::Persistent<v8::Value>>> Instances;
-    robin_hood::unordered_map<std::pair<void*, std::string>, std::shared_ptr<v8::Persistent<v8::Value>>, pair_hash> StructInstances;
-    robin_hood::unordered_map<const void*, std::shared_ptr<v8::Persistent<v8::Object>>> PointerInstances;
-
-    std::function<v8::Local<v8::FunctionTemplate>(v8::Local<v8::Context>, const BaseClassMeta*, KnownUnknownClassPair, const std::vector<std::string>&)> ObjectCtorInitializer;
-    std::function<v8::Local<v8::Function>(v8::Local<v8::Context>, StructInfo)> StructCtorInitializer;
-    robin_hood::unordered_map<std::string, double> Timers;
-    robin_hood::unordered_map<const InterfaceMeta*, std::vector<const MethodMeta*>> Initializers;
-
-    std::unique_ptr<v8::Persistent<v8::Function>> EmptyObjCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> EmptyStructCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> SliceFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> OriginalExtendsFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> WeakRefGetterFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> WeakRefClearFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> SmartJSONStringifyFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> InteropReferenceCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> PointerCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> FunctionReferenceCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    std::unique_ptr<v8::Persistent<v8::Function>> UnmanagedTypeCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
-    
-    
-    using unique_void_ptr = std::unique_ptr<void, void(*)(void const*)>;
-    template<typename T>
-    auto unique_void(T * ptr) -> unique_void_ptr
-    {
-        return unique_void_ptr(ptr, [](void const * data) {
-             T const * p = static_cast<T const*>(data);
-             delete p;
-        });
-    }
-    std::vector<unique_void_ptr> cacheBoundObjects_;
-    template<typename T>
-    void registerCacheBoundObject(T *ptr) {
-        this->cacheBoundObjects_.push_back(unique_void(ptr));
-    }
-private:
+   private:
     v8::Isolate* isolate_;
-    std::shared_ptr<v8::Persistent<v8::Context>> context_;
-    int isolateId_;
+    std::shared_ptr<v8::Persistent<v8::Value>> poWorker_;
+    void* userData_;
+  };
+
+  Caches(v8::Isolate* isolate, const int& isolateId_ = -1);
+  ~Caches();
+
+  bool isWorker = false;
+
+  static std::shared_ptr<ConcurrentMap<std::string, const Meta*>> Metadata;
+  static std::shared_ptr<
+      ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>>
+      Workers;
+
+  inline static std::shared_ptr<Caches> Init(v8::Isolate* isolate,
+                                             const int& isolateId) {
+    auto cache = std::make_shared<Caches>(isolate, isolateId);
+    // create a new shared_ptr that will live until Remove is called
+    isolate->SetData(0, static_cast<void*>(new std::shared_ptr<Caches>(cache)));
+    return cache;
+  }
+  inline static std::shared_ptr<Caches> Get(v8::Isolate* isolate) {
+    auto cache = isolate->GetData(0);
+    if (cache != nullptr) {
+      return *reinterpret_cast<std::shared_ptr<Caches>*>(cache);
+    }
+    // this should only happen when an isolate is accessed after disposal
+    // so we return a dummy cache
+    return std::make_shared<Caches>(isolate);
+  }
+  static void Remove(v8::Isolate* isolate);
+
+  inline int getIsolateId() { return isolateId_; }
+
+  inline void InvalidateIsolate() { isolateId_ = -1; }
+
+  inline bool IsValid() { return isolateId_ != -1; }
+
+  void SetContext(v8::Local<v8::Context> context);
+  v8::Local<v8::Context> GetContext();
+
+  // Per-isolate unhandled promise rejection tracking. Fed by
+  // NativeScriptException::OnPromiseRejected and drained once per runloop turn.
+  std::unique_ptr<PromiseRejectionTracker> PromiseRejections;
+
+  robin_hood::unordered_map<const Meta*,
+                            std::unique_ptr<v8::Persistent<v8::Value>>>
+      Prototypes;
+  robin_hood::unordered_map<std::string,
+                            std::unique_ptr<v8::Persistent<v8::Object>>>
+      ClassPrototypes;
+  robin_hood::unordered_map<
+      const BaseClassMeta*,
+      std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>>
+      CtorFuncTemplates;
+  robin_hood::unordered_map<std::string,
+                            std::unique_ptr<v8::Persistent<v8::Function>>>
+      CtorFuncs;
+  robin_hood::unordered_map<std::string,
+                            std::unique_ptr<v8::Persistent<v8::Function>>>
+      ProtocolCtorFuncs;
+  robin_hood::unordered_map<std::string,
+                            std::unique_ptr<v8::Persistent<v8::Function>>>
+      StructConstructorFunctions;
+  robin_hood::unordered_map<BinaryTypeEncodingType,
+                            std::unique_ptr<v8::Persistent<v8::Object>>>
+      PrimitiveInteropTypes;
+  robin_hood::unordered_map<std::string,
+                            std::unique_ptr<v8::Persistent<v8::Function>>>
+      CFunctions;
+
+  robin_hood::unordered_map<id, std::shared_ptr<v8::Persistent<v8::Value>>>
+      Instances;
+  robin_hood::unordered_map<std::pair<void*, std::string>,
+                            std::shared_ptr<v8::Persistent<v8::Value>>,
+                            pair_hash>
+      StructInstances;
+  robin_hood::unordered_map<const void*,
+                            std::shared_ptr<v8::Persistent<v8::Object>>>
+      PointerInstances;
+
+  std::function<v8::Local<v8::FunctionTemplate>(
+      v8::Local<v8::Context>, const BaseClassMeta*, KnownUnknownClassPair,
+      const std::vector<std::string>&)>
+      ObjectCtorInitializer;
+  std::function<v8::Local<v8::Function>(v8::Local<v8::Context>, StructInfo)>
+      StructCtorInitializer;
+  robin_hood::unordered_map<std::string, double> Timers;
+  robin_hood::unordered_map<const InterfaceMeta*,
+                            std::vector<const MethodMeta*>>
+      Initializers;
+
+  std::unique_ptr<v8::Persistent<v8::Function>> EmptyObjCtorFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> EmptyStructCtorFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> SliceFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> OriginalExtendsFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> WeakRefGetterFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> WeakRefClearFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> SmartJSONStringifyFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> PlaceholderModuleFactoryFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> InteropReferenceCtorFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> PointerCtorFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> FunctionReferenceCtorFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> UnmanagedTypeCtorFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+
+  // Internal EventTarget instance backing the global, returned by the generic
+  // event-primitives bootstrap IIFE (Events::Init). Holds the real listener
+  // store, so native layers dispatch through it without going through
+  // overwritable globals. Cleaned up with the other Persistent members when
+  // Caches is destroyed, before isolate disposal.
+  std::unique_ptr<v8::Persistent<v8::Object>> GlobalEventTarget =
+      std::unique_ptr<v8::Persistent<v8::Object>>(nullptr);
+
+  // Phase 2 WHATWG error-events dispatch closures returned by the bootstrap
+  // IIFE (ErrorEvents::Init). They close over the internal listener store, so
+  // native dispatch keeps working even if app code overwrites
+  // globalThis.dispatchEvent. Cleaned up with the other Persistent members when
+  // Caches is destroyed, before isolate disposal.
+  std::unique_ptr<v8::Persistent<v8::Function>> DispatchErrorEventFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> DispatchUnhandledRejectionFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+  std::unique_ptr<v8::Persistent<v8::Function>> DispatchRejectionHandledFunc =
+      std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+
+  // Phase 3 per-isolate brand for interop.escapeException. An isolate-private
+  // symbol (v8::Private, not a plain Symbol) so user code cannot discover or
+  // forge it. Created lazily via ArgConverter::GetEscapeExceptionBrand and used
+  // to mark/extract escaped native exceptions across JS<->native boundaries.
+  std::unique_ptr<v8::Persistent<v8::Private>> EscapeExceptionBrand =
+      std::unique_ptr<v8::Persistent<v8::Private>>(nullptr);
+
+  using unique_void_ptr = std::unique_ptr<void, void (*)(void const*)>;
+  template <typename T>
+  auto unique_void(T* ptr) -> unique_void_ptr {
+    return unique_void_ptr(ptr, [](void const* data) {
+      T const* p = static_cast<T const*>(data);
+      delete p;
+    });
+  }
+  std::vector<unique_void_ptr> cacheBoundObjects_;
+  template <typename T>
+  void registerCacheBoundObject(T* ptr) {
+    this->cacheBoundObjects_.push_back(unique_void(ptr));
+  }
+
+ private:
+  v8::Isolate* isolate_;
+  std::shared_ptr<v8::Persistent<v8::Context>> context_;
+  int isolateId_;
 };
 
-}
+}  // namespace tns
 
 #endif /* Caches_h */
diff --git a/NativeScript/runtime/ClassBuilder.mm b/NativeScript/runtime/ClassBuilder.mm
index 49c9176d..fa6aabae 100644
--- a/NativeScript/runtime/ClassBuilder.mm
+++ b/NativeScript/runtime/ClassBuilder.mm
@@ -3,6 +3,7 @@
 #include <numeric>
 #include <sstream>
 #include "ArgConverter.h"
+#include "BuiltinLoader.h"
 #include "Caches.h"
 #include "FastEnumerationAdapter.h"
 #include "Helpers.h"
@@ -60,7 +61,8 @@
     auto cache = Caches::Get(isolate);
     auto isolateId = cache->getIsolateId();
 
-    Class extendedClass = ClassBuilder::GetExtendedClass(baseClassName, staticClassName, std::to_string(isolateId) + "_");
+    Class extendedClass = ClassBuilder::GetExtendedClass(baseClassName, staticClassName,
+                                                         std::to_string(isolateId) + "_");
     class_addProtocol(extendedClass, @protocol(TNSDerivedClass));
     class_addProtocol(object_getClass(extendedClass), @protocol(TNSDerivedClass));
 
@@ -156,27 +158,10 @@
     return;
   }
 
-  std::string extendsFuncScript = "(function() { "
-                                  "    function __extends(d, b) { "
-                                  "         for (var p in b) {"
-                                  "             if (b.hasOwnProperty(p)) {"
-                                  "                 d[p] = b[p];"
-                                  "             }"
-                                  "         }"
-                                  "         function __() { this.constructor = d; }"
-                                  "         d.prototype = b === null ? Object.create(b) : "
-                                  "(__.prototype = b.prototype, new __());"
-                                  "    } "
-                                  "    return __extends;"
-                                  "})()";
-
-  Local<Script> script;
-  tns::Assert(Script::Compile(context, tns::ToV8String(isolate, extendsFuncScript.c_str()))
-                  .ToLocal(&script),
-              isolate);
-
   Local<Value> extendsFunc;
-  tns::Assert(script->Run(context).ToLocal(&extendsFunc) && extendsFunc->IsFunction(), isolate);
+  tns::Assert(BuiltinLoader::RunBuiltin(context, BuiltinId::kClassExtends).ToLocal(&extendsFunc) &&
+                  extendsFunc->IsFunction(),
+              isolate);
 
   cache->OriginalExtendsFunc =
       std::make_unique<Persistent<v8::Function>>(isolate, extendsFunc.As<v8::Function>());
@@ -214,8 +199,8 @@
         std::string extendedClassName = tns::ToString(isolate, extendedClassCtorFunc->GetName());
 
         auto isolateId = cache->getIsolateId();
-        __block Class extendedClass =
-            ClassBuilder::GetExtendedClass(baseClassName, extendedClassName, std::to_string(isolateId) + "_");
+        __block Class extendedClass = ClassBuilder::GetExtendedClass(
+            baseClassName, extendedClassName, std::to_string(isolateId) + "_");
         class_addProtocol(extendedClass, @protocol(TNSDerivedClass));
         class_addProtocol(object_getClass(extendedClass), @protocol(TNSDerivedClass));
 
@@ -892,24 +877,40 @@
       FFIMethodCallback getterCallback = [](ffi_cif* cif, void* retValue, void** argValues,
                                             void* userData) {
         PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
-        v8::Locker locker(context->isolate_);
-        Isolate::Scope isolate_scope(context->isolate_);
-        HandleScope handle_scope(context->isolate_);
-        Local<v8::Function> getterFunc = context->callback_->Get(context->isolate_);
-        Local<Value> res;
-
-        id thiz = *static_cast<const id*>(argValues[0]);
-        auto cache = Caches::Get(context->isolate_);
-        auto it = cache->Instances.find(thiz);
-        Local<Object> self_ = it != cache->Instances.end()
-                                  ? it->second->Get(context->isolate_).As<Object>()
-                                  : context->implementationObject_->Get(context->isolate_);
-        Local<Context> v8Context = Caches::Get(context->isolate_)->GetContext();
-        tns::Assert(getterFunc->Call(v8Context, self_, 0, nullptr).ToLocal(&res),
-                    context->isolate_);
-
-        const TypeEncoding* typeEncoding = context->meta_->getter()->encodings()->first();
-        ArgConverter::SetValue(v8Context, retValue, res, typeEncoding);
+        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.
+        NSException* __strong pendingThrow = nil;
+        {
+          v8::Locker locker(isolate);
+          Isolate::Scope isolate_scope(isolate);
+          HandleScope handle_scope(isolate);
+          Local<v8::Function> getterFunc = context->callback_->Get(isolate);
+          Local<Value> res;
+
+          id thiz = *static_cast<const id*>(argValues[0]);
+          auto cache = Caches::Get(isolate);
+          auto it = cache->Instances.find(thiz);
+          Local<Object> self_ = it != cache->Instances.end()
+                                    ? it->second->Get(isolate).As<Object>()
+                                    : context->implementationObject_->Get(isolate);
+          Local<Context> v8Context = Caches::Get(isolate)->GetContext();
+          TryCatch tc(isolate);
+          if (!getterFunc->Call(v8Context, self_, 0, nullptr).ToLocal(&res)) {
+            NSException* ex = ArgConverter::HandleBoundaryException(v8Context, tc);
+            if (ex != nil) {
+              pendingThrow = ex;
+            }
+            // Default getter result on a JS throw: zeroed return buffer.
+            memset(retValue, 0, cif->rtype->size);
+          } else {
+            const TypeEncoding* typeEncoding = context->meta_->getter()->encodings()->first();
+            ArgConverter::SetValue(v8Context, retValue, res, typeEncoding);
+          }
+        }
+        if (pendingThrow != nil) {
+          @throw pendingThrow;
+        }
       };
       const TypeEncoding* typeEncoding = propertyMeta->getter()->encodings()->first();
       IMP impGetter = Interop::CreateMethod(2, 0, typeEncoding, getterCallback, userData);
@@ -926,29 +927,41 @@
       FFIMethodCallback setterCallback = [](ffi_cif* cif, void* retValue, void** argValues,
                                             void* userData) {
         PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
-        v8::Locker locker(context->isolate_);
-        Isolate::Scope isolate_scope(context->isolate_);
-        HandleScope handle_scope(context->isolate_);
-        Local<v8::Function> setterFunc = context->callback_->Get(context->isolate_);
-        Local<Value> res;
-
-        id thiz = *static_cast<const id*>(argValues[0]);
-        auto cache = Caches::Get(context->isolate_);
-        auto it = cache->Instances.find(thiz);
-        Local<Object> self_ = it != cache->Instances.end()
-                                  ? it->second->Get(context->isolate_).As<Object>()
-                                  : context->implementationObject_->Get(context->isolate_);
-
-        uint8_t* argBuffer = (uint8_t*)argValues[2];
-        const TypeEncoding* typeEncoding = context->meta_->setter()->encodings()->first()->next();
-        BaseCall call(argBuffer);
-        Local<Context> v8Context = Caches::Get(context->isolate_)->GetContext();
-        Local<Value> jsWrapper = Interop::GetResult(v8Context, typeEncoding, &call, true);
-        Local<Value> params[1] = {jsWrapper};
-
-        tns::Assert(setterFunc->Call(context->isolate_->GetCurrentContext(), self_, 1, params)
-                        .ToLocal(&res),
-                    context->isolate_);
+        Isolate* isolate = context->isolate_;
+        NSException* __strong pendingThrow = nil;
+        {
+          v8::Locker locker(isolate);
+          Isolate::Scope isolate_scope(isolate);
+          HandleScope handle_scope(isolate);
+          Local<v8::Function> setterFunc = context->callback_->Get(isolate);
+          Local<Value> res;
+
+          id thiz = *static_cast<const id*>(argValues[0]);
+          auto cache = Caches::Get(isolate);
+          auto it = cache->Instances.find(thiz);
+          Local<Object> self_ = it != cache->Instances.end()
+                                    ? it->second->Get(isolate).As<Object>()
+                                    : context->implementationObject_->Get(isolate);
+
+          uint8_t* argBuffer = (uint8_t*)argValues[2];
+          const TypeEncoding* typeEncoding = context->meta_->setter()->encodings()->first()->next();
+          BaseCall call(argBuffer);
+          Local<Context> v8Context = Caches::Get(isolate)->GetContext();
+          Local<Value> jsWrapper = Interop::GetResult(v8Context, typeEncoding, &call, true);
+          Local<Value> params[1] = {jsWrapper};
+
+          TryCatch tc(isolate);
+          if (!setterFunc->Call(v8Context, self_, 1, params).ToLocal(&res)) {
+            NSException* ex = ArgConverter::HandleBoundaryException(v8Context, tc);
+            if (ex != nil) {
+              pendingThrow = ex;
+            }
+            // Setter returns void; nothing to write on a JS throw.
+          }
+        }
+        if (pendingThrow != nil) {
+          @throw pendingThrow;
+        }
       };
 
       const TypeEncoding* typeEncoding = propertyMeta->setter()->encodings()->first();
diff --git a/NativeScript/runtime/DataWrapper.h b/NativeScript/runtime/DataWrapper.h
index 2625acd0..25cfd37b 100644
--- a/NativeScript/runtime/DataWrapper.h
+++ b/NativeScript/runtime/DataWrapper.h
@@ -157,14 +157,26 @@ class BaseDataWrapper {
 
 class EnumDataWrapper : public BaseDataWrapper {
  public:
-  EnumDataWrapper(std::string jsCode) : jsCode_(jsCode) {}
+  EnumDataWrapper(std::string jsCode)
+      : jsCode_(jsCode), hasCachedValue_(false), cachedValue_(0) {}
 
   const WrapperType Type() { return WrapperType::Enum; }
 
   std::string JSCode() { return jsCode_; }
 
+  // Numeric value memoized by Interop::WriteValue so the enum's JS snippet is
+  // compiled and evaluated at most once per wrapper.
+  bool HasCachedValue() const { return hasCachedValue_; }
+  double CachedValue() const { return cachedValue_; }
+  void SetCachedValue(double value) {
+    cachedValue_ = value;
+    hasCachedValue_ = true;
+  }
+
  private:
   std::string jsCode_;
+  bool hasCachedValue_;
+  double cachedValue_;
 };
 
 class PointerTypeWrapper : public BaseDataWrapper {
@@ -524,6 +536,13 @@ class WorkerWrapper : public BaseDataWrapper {
                                              const std::string& source,
                                              const std::string& stackTrace,
                                              int lineNumber, bool async = true);
+  // Forwards a drained unhandled promise rejection to the main isolate's
+  // worker.onerror, guarded against teardown. Shares marshaling with the
+  // exception overload above.
+  void PassUncaughtRejectionToMain(const std::string& message,
+                                   const std::string& source,
+                                   const std::string& stackTrace,
+                                   int lineNumber, bool async = true);
   void PostMessage(std::shared_ptr<worker::Message> message);
   void Close();
   void Terminate();
@@ -561,6 +580,10 @@ class WorkerWrapper : public BaseDataWrapper {
 
   void BackgroundLooper(std::function<v8::Isolate*()> func);
   void DrainPendingTasks();
+  void ForwardErrorPayloadToMain(const std::string& message,
+                                 const std::string& source,
+                                 const std::string& stackTrace, int lineNumber,
+                                 bool async);
   v8::Local<v8::Object> ConstructErrorObject(v8::Local<v8::Context> context,
                                              std::string message,
                                              std::string source,
diff --git a/NativeScript/runtime/DictionaryAdapter.mm b/NativeScript/runtime/DictionaryAdapter.mm
index 1c548163..3cc5a6f0 100644
--- a/NativeScript/runtime/DictionaryAdapter.mm
+++ b/NativeScript/runtime/DictionaryAdapter.mm
@@ -1,9 +1,10 @@
-#import <Foundation/NSString.h>
 #include "DictionaryAdapter.h"
+#import <Foundation/NSString.h>
+#include "ArgConverter.h"
+#include "Caches.h"
 #include "DataWrapper.h"
 #include "Helpers.h"
 #include "Interop.h"
-#include "Caches.h"
 #include "IsolateWrapper.h"
 
 using namespace v8;
@@ -11,31 +12,40 @@
 
 @interface DictionaryAdapterMapKeysEnumerator : NSEnumerator
 
-- (instancetype)initWithMap:(std::shared_ptr<Persistent<Value>>)map isolate:(Isolate*)isolate cache:(std::shared_ptr<Caches>)cache;
+- (instancetype)initWithMap:(std::shared_ptr<Persistent<Value>>)map
+                    isolate:(Isolate*)isolate
+                      cache:(std::shared_ptr<Caches>)cache;
 
 @end
 
 @implementation DictionaryAdapterMapKeysEnumerator {
-    IsolateWrapper* wrapper_;
-    uint32_t index_;
-    std::shared_ptr<Persistent<Value>> map_;
+  IsolateWrapper* wrapper_;
+  uint32_t index_;
+  std::shared_ptr<Persistent<Value>> map_;
 }
 
-- (instancetype)initWithMap:(std::shared_ptr<Persistent<Value>>)map isolate:(Isolate*)isolate cache:(std::shared_ptr<Caches>)cache {
-    if (self) {
-        self->wrapper_ = new IsolateWrapper(isolate);
-        self->index_ = 0;
-        self->map_ = map;
-    }
+- (instancetype)initWithMap:(std::shared_ptr<Persistent<Value>>)map
+                    isolate:(Isolate*)isolate
+                      cache:(std::shared_ptr<Caches>)cache {
+  if (self) {
+    self->wrapper_ = new IsolateWrapper(isolate);
+    self->index_ = 0;
+    self->map_ = map;
+  }
 
-    return self;
+  return self;
 }
 
 - (id)nextObject {
-    if (!wrapper_->IsValid()) {
-        return nil;
-    }
-    Isolate* isolate = wrapper_->Isolate();
+  if (!wrapper_->IsValid()) {
+    return nil;
+  }
+  Isolate* isolate = wrapper_->Isolate();
+  NSString* result = nil;
+  // Scopes-before-@throw: keep V8 scopes in an inner block so a branded escape
+  // is @thrown only after they destruct.
+  NSException* __strong pendingThrow = nil;
+  {
     v8::Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
@@ -44,67 +54,89 @@ - (id)nextObject {
     Local<v8::Array> array = self->map_->Get(isolate).As<Map>()->AsArray();
 
     if (self->index_ < array->Length() - 1) {
-        Local<Value> key;
-        bool success = array->Get(context, self->index_).ToLocal(&key);
-        tns::Assert(success, isolate);
+      Local<Value> key;
+      TryCatch tc(isolate);
+      if (array->Get(context, self->index_).ToLocal(&key)) {
         self->index_ += 2;
-        NSString* result = tns::ToNSString(isolate, key);
-        return result;
+        result = tns::ToNSString(isolate, key);
+      } else {
+        NSException* ex = ArgConverter::HandleBoundaryException(context, tc);
+        if (ex != nil) {
+          pendingThrow = ex;
+        }
+      }
     }
-
-    return nil;
+  }
+  if (pendingThrow != nil) {
+    @throw pendingThrow;
+  }
+  return result;
 }
 
 - (void)dealloc {
-    self->map_ = nil;
-    delete self->wrapper_;
-    
-    [super dealloc];
+  self->map_ = nil;
+  delete self->wrapper_;
+
+  [super dealloc];
 }
 
 @end
 
 @interface DictionaryAdapterObjectKeysEnumerator : NSEnumerator
 
-- (instancetype)initWithProperties:(std::shared_ptr<Persistent<Value>>)dictionary isolate:(Isolate*)isolate cache:(std::shared_ptr<Caches>)cache;
+- (instancetype)initWithProperties:(std::shared_ptr<Persistent<Value>>)dictionary
+                           isolate:(Isolate*)isolate
+                             cache:(std::shared_ptr<Caches>)cache;
 - (Local<v8::Array>)getProperties;
 
 @end
 
 @implementation DictionaryAdapterObjectKeysEnumerator {
-    IsolateWrapper* wrapper_;
-    std::shared_ptr<Persistent<Value>> dictionary_;
-    NSUInteger index_;
+  IsolateWrapper* wrapper_;
+  std::shared_ptr<Persistent<Value>> dictionary_;
+  NSUInteger index_;
 }
 
-- (instancetype)initWithProperties:(std::shared_ptr<Persistent<Value>>)dictionary isolate:(Isolate*)isolate cache:(std::shared_ptr<Caches>)cache {
-    if (self) {
-        self->wrapper_ = new IsolateWrapper(isolate);
-        self->dictionary_ = dictionary;
-        self->index_ = 0;
-    }
+- (instancetype)initWithProperties:(std::shared_ptr<Persistent<Value>>)dictionary
+                           isolate:(Isolate*)isolate
+                             cache:(std::shared_ptr<Caches>)cache {
+  if (self) {
+    self->wrapper_ = new IsolateWrapper(isolate);
+    self->dictionary_ = dictionary;
+    self->index_ = 0;
+  }
 
-    return self;
+  return self;
 }
 
 - (Local<v8::Array>)getProperties {
-    Isolate* isolate = wrapper_->Isolate();
-    v8::Locker locker(isolate);
-    Isolate::Scope isolate_scope(isolate);
-    EscapableHandleScope handle_scope(isolate);
-
-    Local<Context> context = wrapper_->GetCache()->GetContext();
-    Local<v8::Array> properties;
-    Local<Object> dictionary = self->dictionary_->Get(isolate).As<Object>();
-    tns::Assert(dictionary->GetOwnPropertyNames(context).ToLocal(&properties), isolate);
-    return handle_scope.Escape(properties);
+  Isolate* isolate = wrapper_->Isolate();
+  v8::Locker locker(isolate);
+  Isolate::Scope isolate_scope(isolate);
+  EscapableHandleScope handle_scope(isolate);
+
+  Local<Context> context = wrapper_->GetCache()->GetContext();
+  Local<v8::Array> properties;
+  Local<Object> dictionary = self->dictionary_->Get(isolate).As<Object>();
+  TryCatch tc(isolate);
+  if (!dictionary->GetOwnPropertyNames(context).ToLocal(&properties)) {
+    // This helper runs under the caller's V8 scopes and returns a Local, so a
+    // branded escape cannot be safely @thrown from here. Report through the
+    // uncaught path and return an empty array; the caller yields its default.
+    ArgConverter::HandleBoundaryException(context, tc);
+    properties = v8::Array::New(isolate, 0);
+  }
+  return handle_scope.Escape(properties);
 }
 
 - (id)nextObject {
-    if (!wrapper_->IsValid()) {
-        return nil;
-    }
-    Isolate* isolate = wrapper_->Isolate();
+  if (!wrapper_->IsValid()) {
+    return nil;
+  }
+  Isolate* isolate = wrapper_->Isolate();
+  NSString* result = nil;
+  NSException* __strong pendingThrow = nil;
+  {
     v8::Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
@@ -112,69 +144,92 @@ - (id)nextObject {
     Local<Context> context = wrapper_->GetCache()->GetContext();
     Local<v8::Array> properties = [self getProperties];
     if (self->index_ < properties->Length()) {
-        Local<Value> value;
-        bool success = properties->Get(context, (uint)self->index_).ToLocal(&value);
-        tns::Assert(success, isolate);
+      Local<Value> value;
+      TryCatch tc(isolate);
+      if (properties->Get(context, (uint)self->index_).ToLocal(&value)) {
         self->index_++;
-        return tns::ToNSString(isolate, value);
+        result = tns::ToNSString(isolate, value);
+      } else {
+        NSException* ex = ArgConverter::HandleBoundaryException(context, tc);
+        if (ex != nil) {
+          pendingThrow = ex;
+        }
+      }
     }
-
-    return nil;
+  }
+  if (pendingThrow != nil) {
+    @throw pendingThrow;
+  }
+  return result;
 }
 
 - (NSArray*)allObjects {
-    if (!wrapper_->IsValid()) {
-        return nil;
-    }
-    Isolate* isolate = wrapper_->Isolate();
+  if (!wrapper_->IsValid()) {
+    return nil;
+  }
+  Isolate* isolate = wrapper_->Isolate();
+  NSMutableArray* array = [NSMutableArray array];
+  NSException* __strong pendingThrow = nil;
+  {
     v8::Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
 
     Local<Context> context = wrapper_->GetCache()->GetContext();
-    NSMutableArray* array = [NSMutableArray array];
     Local<v8::Array> properties = [self getProperties];
     for (int i = 0; i < properties->Length(); i++) {
-        Local<Value> value;
-        bool success = properties->Get(context, i).ToLocal(&value);
-        tns::Assert(success, isolate);
-        [array addObject:tns::ToNSString(isolate, value)];
+      Local<Value> value;
+      TryCatch tc(isolate);
+      if (!properties->Get(context, i).ToLocal(&value)) {
+        NSException* ex = ArgConverter::HandleBoundaryException(context, tc);
+        if (ex != nil) {
+          pendingThrow = ex;
+        }
+        break;
+      }
+      [array addObject:tns::ToNSString(isolate, value)];
     }
-
-    return array;
+  }
+  if (pendingThrow != nil) {
+    @throw pendingThrow;
+  }
+  return array;
 }
 
 - (void)dealloc {
-    self->dictionary_ = nil;
-    delete self->wrapper_;
-    
-    [super dealloc];
+  self->dictionary_ = nil;
+  delete self->wrapper_;
+
+  [super dealloc];
 }
 
 @end
 
 @implementation DictionaryAdapter {
-    IsolateWrapper* wrapper_;
-    std::shared_ptr<Persistent<Value>> object_;
-    ObjCDataWrapper* dataWrapper_;
+  IsolateWrapper* wrapper_;
+  std::shared_ptr<Persistent<Value>> object_;
+  ObjCDataWrapper* dataWrapper_;
 }
 
 - (instancetype)initWithJSObject:(Local<Object>)jsObject isolate:(Isolate*)isolate {
-    if (self) {
-        self->wrapper_ = new IsolateWrapper(isolate);
-        self->object_ = std::make_shared<Persistent<Value>>(isolate, jsObject);
-        self->wrapper_->GetCache()->Instances.emplace(self, self->object_);
-        tns::SetValue(isolate, jsObject, (self->dataWrapper_ = new ObjCDataWrapper(self)));
-    }
-
-    return self;
+  if (self) {
+    self->wrapper_ = new IsolateWrapper(isolate);
+    self->object_ = std::make_shared<Persistent<Value>>(isolate, jsObject);
+    self->wrapper_->GetCache()->Instances.emplace(self, self->object_);
+    tns::SetValue(isolate, jsObject, (self->dataWrapper_ = new ObjCDataWrapper(self)));
+  }
+
+  return self;
 }
 
 - (NSUInteger)count {
-    if (!wrapper_->IsValid()) {
-        return 0;
-    }
-    Isolate* isolate = wrapper_->Isolate();
+  if (!wrapper_->IsValid()) {
+    return 0;
+  }
+  Isolate* isolate = wrapper_->Isolate();
+  NSUInteger result = 0;
+  NSException* __strong pendingThrow = nil;
+  {
     v8::Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
@@ -182,23 +237,35 @@ - (NSUInteger)count {
     Local<Object> obj = self->object_->Get(isolate).As<Object>();
 
     if (obj->IsMap()) {
-        return obj.As<Map>()->Size();
+      result = obj.As<Map>()->Size();
+    } else {
+      Local<Context> context = wrapper_->GetCache()->GetContext();
+      Local<v8::Array> properties;
+      TryCatch tc(isolate);
+      if (obj->GetOwnPropertyNames(context).ToLocal(&properties)) {
+        result = properties->Length();
+      } else {
+        NSException* ex = ArgConverter::HandleBoundaryException(context, tc);
+        if (ex != nil) {
+          pendingThrow = ex;
+        }
+      }
     }
-
-    Local<Context> context = wrapper_->GetCache()->GetContext();
-    Local<v8::Array> properties;
-    tns::Assert(obj->GetOwnPropertyNames(context).ToLocal(&properties), isolate);
-
-    uint32_t length = properties->Length();
-
-    return length;
+  }
+  if (pendingThrow != nil) {
+    @throw pendingThrow;
+  }
+  return result;
 }
 
 - (id)objectForKey:(id)aKey {
-    if (!wrapper_->IsValid()) {
-        return nil;
-    }
-    Isolate* isolate = wrapper_->Isolate();
+  if (!wrapper_->IsValid()) {
+    return nil;
+  }
+  Isolate* isolate = wrapper_->Isolate();
+  id result = nil;
+  NSException* __strong pendingThrow = nil;
+  {
     v8::Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
@@ -207,74 +274,89 @@ - (id)objectForKey:(id)aKey {
     Local<Object> obj = self->object_->Get(isolate).As<Object>();
 
     Local<Value> value;
+    bool got = false;
+    TryCatch tc(isolate);
     if ([aKey isKindOfClass:[NSNumber class]]) {
-        unsigned int key = [aKey unsignedIntValue];
-        bool success = obj->Get(context, key).ToLocal(&value);
-        tns::Assert(success, isolate);
+      unsigned int key = [aKey unsignedIntValue];
+      got = obj->Get(context, key).ToLocal(&value);
     } else if ([aKey isKindOfClass:[NSString class]]) {
-        NSString* key = (NSString*)aKey;
-        Local<v8::String> keyV8Str = tns::ToV8String(isolate, key);
-
-        if (obj->IsMap()) {
-            Local<Map> map = obj.As<Map>();
-            bool success = map->Get(context, keyV8Str).ToLocal(&value);
-            tns::Assert(success, isolate);
-        } else {
-            bool success = obj->Get(context, keyV8Str).ToLocal(&value);
-            tns::Assert(success, isolate);
-        }
+      NSString* key = (NSString*)aKey;
+      Local<v8::String> keyV8Str = tns::ToV8String(isolate, key);
+
+      if (obj->IsMap()) {
+        Local<Map> map = obj.As<Map>();
+        got = map->Get(context, keyV8Str).ToLocal(&value);
+      } else {
+        got = obj->Get(context, keyV8Str).ToLocal(&value);
+      }
     } else {
-        // TODO: unsupported key type
-        tns::Assert(false, isolate);
+      // Unsupported key type: return the adapter default rather than aborting.
+      got = false;
     }
 
-    id result = Interop::ToObject(context, value);
-
-    return result;
+    if (got) {
+      result = Interop::ToObject(context, value);
+    } else if (tc.HasCaught()) {
+      NSException* ex = ArgConverter::HandleBoundaryException(context, tc);
+      if (ex != nil) {
+        pendingThrow = ex;
+      }
+    }
+  }
+  if (pendingThrow != nil) {
+    @throw pendingThrow;
+  }
+  return result;
 }
 
 - (NSEnumerator*)keyEnumerator {
-    if (!wrapper_->IsValid()) {
-        return nil;
-    }
+  if (!wrapper_->IsValid()) {
+    return nil;
+  }
+  Isolate* isolate = wrapper_->Isolate();
+  v8::Locker locker(isolate);
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+
+  Local<Value> obj = self->object_->Get(isolate);
+
+  if (obj->IsMap()) {
+    return
+        [[[DictionaryAdapterMapKeysEnumerator alloc] initWithMap:self->object_
+                                                         isolate:isolate
+                                                           cache:wrapper_->GetCache()] autorelease];
+  }
+
+  return [[[DictionaryAdapterObjectKeysEnumerator alloc] initWithProperties:self->object_
+                                                                    isolate:isolate
+                                                                      cache:wrapper_->GetCache()]
+      autorelease];
+}
+
+- (void)dealloc {
+  if (wrapper_->IsValid()) {
     Isolate* isolate = wrapper_->Isolate();
     v8::Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
-
-    Local<Value> obj = self->object_->Get(isolate);
-
-    if (obj->IsMap()) {
-        return [[[DictionaryAdapterMapKeysEnumerator alloc] initWithMap:self->object_ isolate:isolate cache:wrapper_->GetCache()] autorelease];
-    }
-    
-    return [[[DictionaryAdapterObjectKeysEnumerator alloc] initWithProperties:self->object_ isolate:isolate cache:wrapper_->GetCache()] autorelease];
-}
-
-- (void)dealloc {
-    if (wrapper_->IsValid()) {
-        Isolate* isolate = wrapper_->Isolate();
-        v8::Locker locker(isolate);
-        Isolate::Scope isolate_scope(isolate);
-        HandleScope handle_scope(isolate);
-        wrapper_->GetCache()->Instances.erase(self);
-        Local<Value> value = self->object_->Get(isolate);
-        BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
-        if (wrapper != nullptr) {
-            if (wrapper == dataWrapper_) {
-                dataWrapper_ = nullptr;
-            }
-            tns::DeleteValue(isolate, value);
-            delete wrapper;
-        }
-    }
-    if (dataWrapper_ != nullptr) {
-        delete dataWrapper_;
+    wrapper_->GetCache()->Instances.erase(self);
+    Local<Value> value = self->object_->Get(isolate);
+    BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
+    if (wrapper != nullptr) {
+      if (wrapper == dataWrapper_) {
+        dataWrapper_ = nullptr;
+      }
+      tns::DeleteValue(isolate, value);
+      delete wrapper;
     }
-    self->object_ = nullptr;
-    delete self->wrapper_;
-    
-    [super dealloc];
+  }
+  if (dataWrapper_ != nullptr) {
+    delete dataWrapper_;
+  }
+  self->object_ = nullptr;
+  delete self->wrapper_;
+
+  [super dealloc];
 }
 
 @end
diff --git a/NativeScript/runtime/ErrorEvents.cpp b/NativeScript/runtime/ErrorEvents.cpp
new file mode 100644
index 00000000..4ce9d54d
--- /dev/null
+++ b/NativeScript/runtime/ErrorEvents.cpp
@@ -0,0 +1,147 @@
+#include "ErrorEvents.h"
+
+#include "BuiltinLoader.h"
+#include "Caches.h"
+#include "Helpers.h"
+#include "NativeScriptException.h"
+
+using namespace v8;
+
+namespace tns {
+
+// Native function handed to the bootstrap IIFE as `nativeReportFatal(error,
+// stackString)`. It runs the terminal tail (shim + fatal log) WITHOUT
+// re-dispatching an event: reportError and listener-thrown errors have already
+// gone through JS dispatch, so dispatching again here would recurse.
+static void NativeReportFatalCallback(const FunctionCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  Local<Value> error =
+      info.Length() > 0 ? info[0] : v8::Undefined(isolate).As<Value>();
+  std::string stack = info.Length() > 1 ? tns::ToString(isolate, info[1]) : "";
+  NativeScriptException::ReportFatalTail(isolate, error, Local<v8::Message>(),
+                                         stack, "");
+}
+
+void ErrorEvents::Init(Local<Context> context) {
+  // WHATWG error-events layer, layered on top of the generic event primitives
+  // installed by Events::Init. Plain (module-free) script, strict inside the
+  // IIFE, ES5-ish so it never depends on other runtime extensions. The IIFE is
+  // invoked with two arguments — the internal EventTarget backing the global
+  // (so native dispatch survives app code overwriting globalThis.dispatchEvent)
+  // and the native nativeReportFatal(error, stack) function that runs the
+  // terminal tail — and returns three closures bound to that backing store.
+  // ErrorEvent/PromiseRejectionEvent subclass the Event captured off globalThis
+  // at init time, which runs before any user code.
+  Isolate* isolate = context->GetIsolate();
+
+  auto cache = Caches::Get(isolate);
+  tns::Assert(cache != nullptr && cache->GlobalEventTarget != nullptr, isolate);
+  Local<Object> globalTarget = cache->GlobalEventTarget->Get(isolate);
+
+  Local<Value> result;
+  bool success = BuiltinLoader::RunBuiltin(context, BuiltinId::kErrorEvents)
+                     .ToLocal(&result);
+  tns::Assert(success && result->IsFunction(), isolate);
+
+  Local<v8::Function> iife = result.As<v8::Function>();
+
+  Local<v8::Function> nativeReportFatal;
+  success = v8::Function::New(context, NativeReportFatalCallback)
+                .ToLocal(&nativeReportFatal);
+  tns::Assert(success, isolate);
+
+  Local<Value> installArgs[] = {globalTarget, nativeReportFatal};
+  Local<Value> iifeResult;
+  success = iife->Call(context, context->Global(), 2, installArgs)
+                .ToLocal(&iifeResult);
+  tns::Assert(success && iifeResult->IsArray(), isolate);
+
+  Local<v8::Array> closures = iifeResult.As<v8::Array>();
+  Local<Value> errorFn, rejectionFn, handledFn;
+  tns::Assert(
+      closures->Get(context, 0).ToLocal(&errorFn) && errorFn->IsFunction(),
+      isolate);
+  tns::Assert(closures->Get(context, 1).ToLocal(&rejectionFn) &&
+                  rejectionFn->IsFunction(),
+              isolate);
+  tns::Assert(
+      closures->Get(context, 2).ToLocal(&handledFn) && handledFn->IsFunction(),
+      isolate);
+
+  cache->DispatchErrorEventFunc = std::make_unique<Persistent<v8::Function>>(
+      isolate, errorFn.As<v8::Function>());
+  cache->DispatchUnhandledRejectionFunc =
+      std::make_unique<Persistent<v8::Function>>(
+          isolate, rejectionFn.As<v8::Function>());
+  cache->DispatchRejectionHandledFunc =
+      std::make_unique<Persistent<v8::Function>>(isolate,
+                                                 handledFn.As<v8::Function>());
+}
+
+// Dispatches the cancelable `error` ErrorEvent through the JS listener store.
+// Returns true when a listener called preventDefault(). A dispatch that itself
+// throws is logged and treated as unprevented so an error is never lost.
+bool ErrorEvents::DispatchError(Isolate* isolate, Local<Value> error,
+                                const std::string& messageString,
+                                const std::string& stack) {
+  auto cache = Caches::Get(isolate);
+  if (cache == nullptr || cache->DispatchErrorEventFunc == nullptr) {
+    return false;
+  }
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<v8::Function> dispatch = cache->DispatchErrorEventFunc->Get(isolate);
+  Local<Value> args[] = {error, tns::ToV8String(isolate, messageString),
+                         tns::ToV8String(isolate, stack)};
+  Local<Value> result;
+  TryCatch tc(isolate);
+  bool success =
+      dispatch->Call(context, context->Global(), 3, args).ToLocal(&result);
+  if (tc.HasCaught()) {
+    tns::LogError(isolate, tc);
+    return false;
+  }
+  return success && !result.IsEmpty() && result->BooleanValue(isolate);
+}
+
+bool ErrorEvents::DispatchUnhandledRejection(Isolate* isolate,
+                                             Local<Promise> promise,
+                                             Local<Value> reason) {
+  auto cache = Caches::Get(isolate);
+  if (cache == nullptr || cache->DispatchUnhandledRejectionFunc == nullptr) {
+    return false;
+  }
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<v8::Function> dispatch =
+      cache->DispatchUnhandledRejectionFunc->Get(isolate);
+  Local<Value> args[] = {promise, reason};
+  Local<Value> result;
+  TryCatch tc(isolate);
+  bool success =
+      dispatch->Call(context, context->Global(), 2, args).ToLocal(&result);
+  if (tc.HasCaught()) {
+    tns::LogError(isolate, tc);
+    return false;
+  }
+  return success && !result.IsEmpty() && result->BooleanValue(isolate);
+}
+
+void ErrorEvents::DispatchRejectionHandled(Isolate* isolate,
+                                           Local<Promise> promise,
+                                           Local<Value> reason) {
+  auto cache = Caches::Get(isolate);
+  if (cache == nullptr || cache->DispatchRejectionHandledFunc == nullptr) {
+    return;
+  }
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<v8::Function> dispatch =
+      cache->DispatchRejectionHandledFunc->Get(isolate);
+  Local<Value> args[] = {promise, reason};
+  Local<Value> result;
+  TryCatch tc(isolate);
+  if (!dispatch->Call(context, context->Global(), 2, args).ToLocal(&result) &&
+      tc.HasCaught()) {
+    tns::LogError(isolate, tc);
+  }
+}
+
+}  // namespace tns
diff --git a/NativeScript/runtime/ErrorEvents.h b/NativeScript/runtime/ErrorEvents.h
new file mode 100644
index 00000000..0c885e9d
--- /dev/null
+++ b/NativeScript/runtime/ErrorEvents.h
@@ -0,0 +1,46 @@
+#ifndef ErrorEvents_h
+#define ErrorEvents_h
+
+#include <string>
+
+#include "Common.h"
+
+namespace tns {
+
+class ErrorEvents {
+ public:
+  // Installs the WHATWG error-events layer on top of the generic event
+  // primitives: the ErrorEvent and PromiseRejectionEvent constructors
+  // (subclassing the Event installed by Events::Init, captured off globalThis
+  // at init time) and global reportError. Evaluated once per isolate during
+  // Runtime::Init, right after Events::Init, for both main and worker isolates.
+  // The bootstrap IIFE is invoked with the backing event target
+  // (Caches->GlobalEventTarget) and the native nativeReportFatal(error, stack)
+  // function, and returns three closures bound to the internal listener store;
+  // they are stashed in Caches so native dispatch survives app code overwriting
+  // globalThis.dispatchEvent.
+  static void Init(v8::Local<v8::Context> context);
+  // Dispatches the cancelable `error` ErrorEvent through the JS listener store.
+  // Returns true when a listener called preventDefault(). A dispatch that
+  // itself throws is logged and treated as unprevented so an error is never
+  // lost.
+  static bool DispatchError(v8::Isolate* isolate, v8::Local<v8::Value> error,
+                            const std::string& messageString,
+                            const std::string& stack);
+  // Dispatches the cancelable `unhandledrejection` PromiseRejectionEvent
+  // through the JS listener store. Returns true when a listener called
+  // preventDefault(). Never re-dispatches on failure: a dispatch that itself
+  // throws is logged and treated as unprevented so the error is never lost.
+  static bool DispatchUnhandledRejection(v8::Isolate* isolate,
+                                         v8::Local<v8::Promise> promise,
+                                         v8::Local<v8::Value> reason);
+  // Fires the non-cancelable `rejectionhandled` PromiseRejectionEvent for a
+  // late-attached handler, carrying the original rejection reason.
+  static void DispatchRejectionHandled(v8::Isolate* isolate,
+                                       v8::Local<v8::Promise> promise,
+                                       v8::Local<v8::Value> reason);
+};
+
+}  // namespace tns
+
+#endif /* ErrorEvents_h */
diff --git a/NativeScript/runtime/Events.cpp b/NativeScript/runtime/Events.cpp
new file mode 100644
index 00000000..8f562bb5
--- /dev/null
+++ b/NativeScript/runtime/Events.cpp
@@ -0,0 +1,38 @@
+#include "Events.h"
+
+#include "BuiltinLoader.h"
+#include "Caches.h"
+#include "Helpers.h"
+
+using namespace v8;
+
+namespace tns {
+
+void Events::Init(Local<Context> context) {
+  // Generic WHATWG event primitives. Plain (module-free) script, strict inside
+  // the IIFE, ES5-ish so it never depends on other runtime extensions. The IIFE
+  // installs Event/EventTarget and the global EventTarget methods, then returns
+  // the internal EventTarget instance backing the global so native dispatch
+  // survives app code overwriting globalThis.dispatchEvent. The error-events
+  // layer (ErrorEvents::Init) runs immediately after and installs the native
+  // listener-error reporter through _installListenerErrorReporter.
+  Isolate* isolate = context->GetIsolate();
+
+  Local<Value> result;
+  bool success =
+      BuiltinLoader::RunBuiltin(context, BuiltinId::kEvents).ToLocal(&result);
+  tns::Assert(success && result->IsFunction(), isolate);
+
+  Local<v8::Function> iife = result.As<v8::Function>();
+
+  Local<Value> iifeResult;
+  success =
+      iife->Call(context, context->Global(), 0, nullptr).ToLocal(&iifeResult);
+  tns::Assert(success && iifeResult->IsObject(), isolate);
+
+  auto cache = Caches::Get(isolate);
+  cache->GlobalEventTarget = std::make_unique<Persistent<v8::Object>>(
+      isolate, iifeResult.As<Object>());
+}
+
+}  // namespace tns
diff --git a/NativeScript/runtime/Events.h b/NativeScript/runtime/Events.h
new file mode 100644
index 00000000..8a2331e7
--- /dev/null
+++ b/NativeScript/runtime/Events.h
@@ -0,0 +1,23 @@
+#ifndef Events_h
+#define Events_h
+
+#include "Common.h"
+
+namespace tns {
+
+class Events {
+ public:
+  // Installs the generic WHATWG event primitives: the Event and EventTarget
+  // constructors on globalThis, the EventTarget methods (addEventListener /
+  // removeEventListener / dispatchEvent) bound onto globalThis, and the
+  // internal EventTarget instance backing the global. Evaluated once per
+  // isolate during Runtime::Init, right after PromiseProxy::Init and before
+  // ErrorEvents::Init, for both main and worker isolates. Stashes the backing
+  // target in Caches->GlobalEventTarget so native layers can dispatch without
+  // going through overwritable globals.
+  static void Init(v8::Local<v8::Context> context);
+};
+
+}  // namespace tns
+
+#endif /* Events_h */
diff --git a/NativeScript/runtime/FastEnumerationAdapter.mm b/NativeScript/runtime/FastEnumerationAdapter.mm
index f43700c1..cbb4d1d8 100644
--- a/NativeScript/runtime/FastEnumerationAdapter.mm
+++ b/NativeScript/runtime/FastEnumerationAdapter.mm
@@ -1,89 +1,100 @@
-#import <Foundation/Foundation.h>
 #include "FastEnumerationAdapter.h"
-#include "NativeScriptException.h"
-#include "Interop.h"
+#import <Foundation/Foundation.h>
 #include "Helpers.h"
 #include "Interop.h"
+#include "NativeScriptException.h"
 
 using namespace v8;
 
 namespace tns {
 
-NSUInteger FastEnumerationAdapter(Isolate* isolate, id self, NSFastEnumerationState* state, __unsafe_unretained id buffer[], NSUInteger length, Persistent<v8::Function>* poIteratorFunc) {
-    enum State : decltype(state->state) {
-        Uninitialized = 0,
-        Iterating,
-        Done
-    };
-
-    NSUInteger count = 0;
-
-    try {
-        if (state->state == State::Uninitialized) {
-            Local<Value> iteratorRes;
-            Local<Context> context = isolate->GetCurrentContext();
-            Local<v8::Function> iteratorFunc = poIteratorFunc->Get(isolate);
-            if (!iteratorFunc->Call(context, context->Global(), 0, {}).ToLocal(&iteratorRes)) {
-                tns::Assert(false, isolate);
-            }
-
-            tns::Assert(!iteratorRes.IsEmpty() && iteratorRes->IsObject(), isolate);
-            Local<Object> iteratorObj = iteratorRes.As<Object>();
-
-            void* selfPtr = (__bridge void*)self;
-            state->mutationsPtr = reinterpret_cast<unsigned long*>(selfPtr);
-            state->extra[0] = reinterpret_cast<unsigned long>(new Persistent<Object>(isolate, iteratorObj));
-            state->state = State::Iterating;
-        }
-
-        if (state->state == State::Done) {
-            return 0;
-        }
-
-        Persistent<Object>* poIteratorObj = reinterpret_cast<Persistent<Object>*>(state->extra[0]);
-        Local<Object> iteratorObj = poIteratorObj->Get(isolate);
-        Local<Context> context = isolate->GetCurrentContext();
-        Local<Value> next;
-        bool success = iteratorObj->Get(context, tns::ToV8String(isolate, "next")).ToLocal(&next);
-        tns::Assert(success && !next.IsEmpty() && next->IsFunction(), isolate);
-
-        state->itemsPtr = buffer;
-        while (count < length) {
-            Local<v8::Function> nextFunc = next.As<v8::Function>();
-            Local<Context> context = isolate->GetCurrentContext();
-            Local<Value> nextResult;
-            if (!nextFunc->Call(context, iteratorObj, 0, {}).ToLocal(&nextResult)) {
-                tns::Assert(false, isolate);
-            }
-
-            if (nextResult.IsEmpty() || !nextResult->IsObject()) {
-                throw NativeScriptException("The \"next\" method must return an object with at least the \"value\" or \"done\" properties");
-            }
-
-            Local<Value> done;
-            bool success = nextResult.As<Object>()->Get(context, tns::ToV8String(isolate, "done")).ToLocal(&done);
-            tns::Assert(success && tns::IsBool(done), isolate);
-
-            if (tns::ToBool(done)) {
-                poIteratorObj->Reset();
-                delete poIteratorObj;
-                state->state = State::Done;
-                break;
-            }
-
-            Local<Value> value;
-            success = nextResult.As<Object>()->Get(context, tns::ToV8String(isolate, "value")).ToLocal(&value);
-            tns::Assert(success && !value.IsEmpty(), isolate);
-
-            id result = Interop::ToObject(context, value);
-            *buffer++ = result;
-            count++;
-        }
-    } catch (NativeScriptException& ex) {
-        ex.ReThrowToV8(isolate);
+NSUInteger FastEnumerationAdapter(Isolate* isolate, id self, NSFastEnumerationState* state,
+                                  __unsafe_unretained id buffer[], NSUInteger length,
+                                  Persistent<v8::Function>* poIteratorFunc) {
+  enum State : decltype(state->state) { Uninitialized = 0, Iterating, Done };
+
+  NSUInteger count = 0;
+
+  try {
+    if (state->state == State::Uninitialized) {
+      Local<Value> iteratorRes;
+      Local<Context> context = isolate->GetCurrentContext();
+      Local<v8::Function> iteratorFunc = poIteratorFunc->Get(isolate);
+      TryCatch tc(isolate);
+      if (!iteratorFunc->Call(context, context->Global(), 0, {}).ToLocal(&iteratorRes)) {
+        // JS threw while obtaining the iterator. Surface it to V8 (the
+        // outer catch ReThrowsToV8) rather than aborting the process.
+        // NOTE: this native fast-enumeration boundary runs under the
+        // caller's V8 scopes, so a branded escapeException cannot be
+        // safely @thrown here; it surfaces as a JS exception instead.
+        throw NativeScriptException(isolate, tc, "Error calling the iterator function");
+      }
+
+      tns::Assert(!iteratorRes.IsEmpty() && iteratorRes->IsObject(), isolate);
+      Local<Object> iteratorObj = iteratorRes.As<Object>();
+
+      void* selfPtr = (__bridge void*)self;
+      state->mutationsPtr = reinterpret_cast<unsigned long*>(selfPtr);
+      state->extra[0] =
+          reinterpret_cast<unsigned long>(new Persistent<Object>(isolate, iteratorObj));
+      state->state = State::Iterating;
     }
 
-    return count;
-}
+    if (state->state == State::Done) {
+      return 0;
+    }
 
+    Persistent<Object>* poIteratorObj = reinterpret_cast<Persistent<Object>*>(state->extra[0]);
+    Local<Object> iteratorObj = poIteratorObj->Get(isolate);
+    Local<Context> context = isolate->GetCurrentContext();
+    Local<Value> next;
+    bool success = iteratorObj->Get(context, tns::ToV8String(isolate, "next")).ToLocal(&next);
+    tns::Assert(success && !next.IsEmpty() && next->IsFunction(), isolate);
+
+    state->itemsPtr = buffer;
+    while (count < length) {
+      Local<v8::Function> nextFunc = next.As<v8::Function>();
+      Local<Context> context = isolate->GetCurrentContext();
+      Local<Value> nextResult;
+      TryCatch tc(isolate);
+      if (!nextFunc->Call(context, iteratorObj, 0, {}).ToLocal(&nextResult)) {
+        // Surface a JS throw from the iterator's next() to V8 rather than
+        // aborting (see note above about the branded-escape limitation).
+        throw NativeScriptException(isolate, tc,
+                                    "Error calling the \"next\" method of the iterator");
+      }
+
+      if (nextResult.IsEmpty() || !nextResult->IsObject()) {
+        throw NativeScriptException("The \"next\" method must return an object with at least the "
+                                    "\"value\" or \"done\" properties");
+      }
+
+      Local<Value> done;
+      bool success =
+          nextResult.As<Object>()->Get(context, tns::ToV8String(isolate, "done")).ToLocal(&done);
+      tns::Assert(success && tns::IsBool(done), isolate);
+
+      if (tns::ToBool(done)) {
+        poIteratorObj->Reset();
+        delete poIteratorObj;
+        state->state = State::Done;
+        break;
+      }
+
+      Local<Value> value;
+      success =
+          nextResult.As<Object>()->Get(context, tns::ToV8String(isolate, "value")).ToLocal(&value);
+      tns::Assert(success && !value.IsEmpty(), isolate);
+
+      id result = Interop::ToObject(context, value);
+      *buffer++ = result;
+      count++;
+    }
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+  }
+
+  return count;
 }
+
+}  // namespace tns
diff --git a/NativeScript/runtime/Helpers.mm b/NativeScript/runtime/Helpers.mm
index 6d3cab9d..028319c3 100644
--- a/NativeScript/runtime/Helpers.mm
+++ b/NativeScript/runtime/Helpers.mm
@@ -10,6 +10,7 @@
 #include <fstream>
 #include <locale>
 #include <sstream>
+#include "BuiltinLoader.h"
 #include "Caches.h"
 #include "NativeScriptException.h"
 #include "Runtime.h"
@@ -484,43 +485,13 @@
     return caches->SmartJSONStringifyFunc->Get(isolate);
   }
 
-  std::string smartStringifyFunctionScript =
-      "(function () {\n"
-      "    function smartStringify(object) {\n"
-      "        const seen = [];\n"
-      "        var replacer = function (key, value) {\n"
-      "            if (value != null && typeof value == \"object\") {\n"
-      "                if (seen.indexOf(value) >= 0) {\n"
-      "                    if (key) {\n"
-      "                        return \"[Circular]\";\n"
-      "                    }\n"
-      "                    return;\n"
-      "                }\n"
-      "                seen.push(value);\n"
-      "            }\n"
-      "            return value;\n"
-      "        };\n"
-      "        return JSON.stringify(object, replacer, 2);\n"
-      "    }\n"
-      "    return smartStringify;\n"
-      "})();";
-
-  Local<v8::String> source = tns::ToV8String(isolate, smartStringifyFunctionScript);
   Local<Context> context = isolate->GetCurrentContext();
 
-  Local<Script> script;
-  bool success = Script::Compile(context, source).ToLocal(&script);
-  tns::Assert(success, isolate);
-
-  if (script.IsEmpty()) {
-    return Local<v8::Function>();
-  }
-
   Local<Value> result;
-  success = script->Run(context).ToLocal(&result);
+  bool success = BuiltinLoader::RunBuiltin(context, BuiltinId::kSmartStringify).ToLocal(&result);
   tns::Assert(success, isolate);
 
-  if (result.IsEmpty() && !result->IsFunction()) {
+  if (result.IsEmpty() || !result->IsFunction()) {
     return Local<v8::Function>();
   }
 
diff --git a/NativeScript/runtime/InlineFunctions.cpp b/NativeScript/runtime/InlineFunctions.cpp
index 0e748296..f5f20a3b 100644
--- a/NativeScript/runtime/InlineFunctions.cpp
+++ b/NativeScript/runtime/InlineFunctions.cpp
@@ -1,4 +1,6 @@
 #include "InlineFunctions.h"
+
+#include "BuiltinLoader.h"
 #include "Helpers.h"
 
 using namespace v8;
@@ -6,139 +8,21 @@ using namespace v8;
 namespace tns {
 
 void InlineFunctions::Init(Local<Context> context) {
+  Isolate* isolate = context->GetIsolate();
 
-    std::string inlineFunctionsSource =
-        "Object.assign(global, {"
-        "    CGPointMake(x, y) {"
-        "        return new CGPoint({ x, y });"
-        "    },"
-        "    CGRectMake(x, y, width, height) {"
-        "        return new CGRect({ origin: { x, y }, size: { width, height } });"
-        "    },"
-        "    CGSizeMake(width, height) {"
-        "        return new CGSize({ width, height });"
-        "    },"
-        "    UIEdgeInsetsMake(top, left, bottom, right) {"
-        "        return new UIEdgeInsets({ top, left, bottom, right });"
-        "    },"
-        "    NSMakeRange(location, length) {"
-        "        return new NSRange({ location, length });"
-        "    },"
-        ""
-        "    __decorate(decorators, target, key, desc) {"
-        "        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;"
-        "        if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);"
-        "        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;"
-        "        return c > 3 && r && Object.defineProperty(target, key, r), r;"
-        "    },"
-        "    __param(paramIndex, decorator) {"
-        "        return function (target, key) { decorator(target, key, paramIndex); }"
-        "    },"
-        ""
-        "    ObjCClass() {"
-        "        var protocols = Array.from(arguments);"
-        "        return function (target) {"
-        "            if (protocols.length > 0) {"
-        "                target.ObjCProtocols = (target.ObjCProtocols && target.ObjCProtocols instanceof Array ? target.ObjCProtocols.concat(protocols) : protocols);"
-        "            }"
-        "        }"
-        "    },"
-        "    ObjCMethod() {"
-        "        var name = arguments[0];"
-        "        var hasName = (name !== undefined && typeof name === \"string\");"
-        "        var returnType = (hasName ? arguments[1] : arguments[0]);"
-        ""
-        "        return function (target, propertyKey, descriptor) {"
-        "            if (!target.constructor.ObjCExposedMethods) {"
-        "                target.constructor.ObjCExposedMethods = {};"
-        "            }"
-        "            if (!target.constructor.ObjCExposedMethods[propertyKey]) {"
-        "                target.constructor.ObjCExposedMethods[propertyKey] = {};"
-        "            }"
-        "            target.constructor.ObjCExposedMethods[propertyKey].returns = returnType || interop.types.void;"
-        ""
-        "            if (hasName && name !== propertyKey) {"
-        "                target.constructor.ObjCExposedMethods[name] = target.constructor.ObjCExposedMethods[propertyKey];"
-        "                delete target.constructor.ObjCExposedMethods[propertyKey];"
-        ""
-        "                target[name] = function () { "
-        "                    return this[propertyKey].apply(this, arguments);"
-        "                }"
-        "            }"
-        "        }"
-        "    },"
-        "    ObjC() {"
-        "        var args = Array.from(arguments);"
-        ""
-        "        return function (target, propertyKey, descriptor) {"
-        "            if (propertyKey === undefined) {"
-        "                return ObjCClass.apply(this, args)(target);"
-        "            }"
-        ""
-        "            ObjCMethod.apply(this, args)(target, propertyKey, descriptor);"
-        "        };"
-        "    },"
-        "    ObjCParam(type) {"
-        "        return function (target, propertyKey, parameterIndex) {"
-        "            if (!target.constructor.ObjCExposedMethods) {"
-        "                target.constructor.ObjCExposedMethods = {};"
-        "            }"
-        "            if (!target.constructor.ObjCExposedMethods[propertyKey]) {"
-        "                target.constructor.ObjCExposedMethods[propertyKey] = {};"
-        "            }"
-        "            var exposedMethod = target.constructor.ObjCExposedMethods[propertyKey];"
-        "            if (!exposedMethod.params) {"
-        "                exposedMethod.params = [];"
-        "            }"
-        "            exposedMethod.params[parameterIndex] = type || interop.types.void;"
-        "        };"
-        "    },"
-        ""
-        "});"
-        ""
-        "Object.defineProperty(global, \"__tsEnum\", {"
-        "    writable: false,"
-        "    enumerable: false,"
-        "    configurable: false,"
-        "    value: function(obj) {"
-        "        var result = {};"
-        "        for (var key of Object.keys(obj)) {"
-        "            result[key] = obj[key];"
-        "            result[obj[key]] = key;"
-        "        }"
-        "        return result;"
-        "    }"
-        "});"
-    ;
-
-    Isolate* isolate = context->GetIsolate();
-
-    Local<Script> script;
-    if (!Script::Compile(context, tns::ToV8String(isolate, inlineFunctionsSource)).ToLocal(&script)) {
-        tns::Assert(false, isolate);
-    }
-    tns::Assert(!script.IsEmpty(), isolate);
-
-    Local<Value> result;
-    if (!script->Run(context).ToLocal(&result)) {
-        tns::Assert(false, isolate);
-    }
+  Local<Value> result;
+  if (!BuiltinLoader::RunBuiltin(context, BuiltinId::kInlineFunctions)
+           .ToLocal(&result)) {
+    tns::Assert(false, isolate);
+  }
 }
 
 bool InlineFunctions::IsGlobalFunction(std::string name) {
-    return
-        name == "CGPointMake" ||
-        name == "CGRectMake" ||
-        name == "CGSizeMake" ||
-        name == "UIEdgeInsetsMake" ||
-        name == "NSMakeRange" ||
-        name == "__decorate" ||
-        name == "__param" ||
-        name == "ObjCClass" ||
-        name == "ObjCMethod" ||
-        name == "ObjC" ||
-        name == "ObjCParam" ||
-        name == "__tsEnum";
+  return name == "CGPointMake" || name == "CGRectMake" ||
+         name == "CGSizeMake" || name == "UIEdgeInsetsMake" ||
+         name == "NSMakeRange" || name == "__decorate" || name == "__param" ||
+         name == "ObjCClass" || name == "ObjCMethod" || name == "ObjC" ||
+         name == "ObjCParam" || name == "__tsEnum";
 }
 
-}
+}  // namespace tns
diff --git a/NativeScript/runtime/Interop.h b/NativeScript/runtime/Interop.h
index 3980be17..db7bd20f 100644
--- a/NativeScript/runtime/Interop.h
+++ b/NativeScript/runtime/Interop.h
@@ -3,203 +3,221 @@
 
 #include <CoreFoundation/CFBase.h>
 #include <objc/message.h>
-#include "libffi.h"
+
 #include "Common.h"
-#include "Metadata.h"
 #include "DataWrapper.h"
 #include "FFICall.h"
+#include "Metadata.h"
+#include "libffi.h"
 
 namespace tns {
 
-typedef void (*FFIMethodCallback)(ffi_cif* cif, void* retValue, void** argValues, void* userData);
+typedef void (*FFIMethodCallback)(ffi_cif* cif, void* retValue,
+                                  void** argValues, void* userData);
 
 struct MethodCall {
-    MethodCall(v8::Local<v8::Context> context,
-        bool isPrimitiveFunction,
-        void* functionPointer,
-        const TypeEncoding* typeEncoding,
-        V8Args& args,
-        id target,
-        Class clazz,
-        SEL selector,
-        bool callSuper,
-        MetaType metaType,
-        bool provideErrorOutParameter,
-        bool ownsReturnedObject,
-        bool returnsUnmanaged,
-        bool isInitializer)
-        : context_(context),
-          isPrimitiveFunction_(isPrimitiveFunction),
-          functionPointer_(functionPointer),
-          typeEncoding_(typeEncoding),
-          args_(args),
-          target_(target),
-          clazz_(clazz),
-          selector_(selector),
-          callSuper_(callSuper),
-          metaType_(metaType),
-          provideErrorOutParameter_(provideErrorOutParameter),
-          ownsReturnedObject_(ownsReturnedObject),
-          returnsUnmanaged_(returnsUnmanaged),
-          isInitializer_(isInitializer) {
-    }
+  MethodCall(v8::Local<v8::Context> context, bool isPrimitiveFunction,
+             void* functionPointer, const TypeEncoding* typeEncoding,
+             V8Args& args, id target, Class clazz, SEL selector, bool callSuper,
+             MetaType metaType, bool provideErrorOutParameter,
+             bool ownsReturnedObject, bool returnsUnmanaged, bool isInitializer)
+      : context_(context),
+        isPrimitiveFunction_(isPrimitiveFunction),
+        functionPointer_(functionPointer),
+        typeEncoding_(typeEncoding),
+        args_(args),
+        target_(target),
+        clazz_(clazz),
+        selector_(selector),
+        callSuper_(callSuper),
+        metaType_(metaType),
+        provideErrorOutParameter_(provideErrorOutParameter),
+        ownsReturnedObject_(ownsReturnedObject),
+        returnsUnmanaged_(returnsUnmanaged),
+        isInitializer_(isInitializer) {}
 
-    v8::Local<v8::Context> context_;
-    bool isPrimitiveFunction_;
-    void* functionPointer_;
-    const TypeEncoding* typeEncoding_;
-    V8Args& args_;
-    id target_;
-    Class clazz_;
-    SEL selector_;
-    bool callSuper_;
-    MetaType metaType_;
-    bool provideErrorOutParameter_;
-    bool ownsReturnedObject_;
-    bool returnsUnmanaged_;
-    bool isInitializer_;
+  v8::Local<v8::Context> context_;
+  bool isPrimitiveFunction_;
+  void* functionPointer_;
+  const TypeEncoding* typeEncoding_;
+  V8Args& args_;
+  id target_;
+  Class clazz_;
+  SEL selector_;
+  bool callSuper_;
+  MetaType metaType_;
+  bool provideErrorOutParameter_;
+  bool ownsReturnedObject_;
+  bool returnsUnmanaged_;
+  bool isInitializer_;
 };
 
-struct CMethodCall: MethodCall {
-    CMethodCall(
-        v8::Local<v8::Context> context,
-        void* functionPointer,
-        const TypeEncoding* typeEncoding,
-        V8Args& args,
-        bool ownsReturnedObject,
-        bool returnsUnmanaged)
-        : MethodCall(
-            context,
-            true,
-            functionPointer,
-            typeEncoding,
-            args,
-            nil,
-            nil,
-            nil,
-            false,
-            MetaType::Undefined,
-            false,
-            ownsReturnedObject,
-            returnsUnmanaged,
-            false) {
-    }
+struct CMethodCall : MethodCall {
+  CMethodCall(v8::Local<v8::Context> context, void* functionPointer,
+              const TypeEncoding* typeEncoding, V8Args& args,
+              bool ownsReturnedObject, bool returnsUnmanaged)
+      : MethodCall(context, true, functionPointer, typeEncoding, args, nil, nil,
+                   nil, false, MetaType::Undefined, false, ownsReturnedObject,
+                   returnsUnmanaged, false) {}
 };
 
-struct ObjCMethodCall: public MethodCall {
-    ObjCMethodCall(
-        v8::Local<v8::Context> context,
-        const MethodMeta* meta,
-        id target,
-        Class clazz,
-        V8Args& args,
-        bool callSuper)
-        : MethodCall(
-            context,
-            false,
-            callSuper ? (void*)objc_msgSendSuper : (void*)objc_msgSend,
-            meta->encodings()->first(),
-            args,
-            target,
-            clazz,
-            meta->selector(),
-            callSuper,
-            meta->type(),
-            meta->hasErrorOutParameter() && args.Length() < meta->encodings()->count - 1,
-            meta->ownsReturnedCocoaObject(),
-            false,
-            meta->isInitializer()) {
-        }
+struct ObjCMethodCall : public MethodCall {
+  ObjCMethodCall(v8::Local<v8::Context> context, const MethodMeta* meta,
+                 id target, Class clazz, V8Args& args, bool callSuper)
+      : MethodCall(context, false,
+                   callSuper ? (void*)objc_msgSendSuper : (void*)objc_msgSend,
+                   meta->encodings()->first(), args, target, clazz,
+                   meta->selector(), callSuper, meta->type(),
+                   meta->hasErrorOutParameter() &&
+                       args.Length() < meta->encodings()->count - 1,
+                   meta->ownsReturnedCocoaObject(), false,
+                   meta->isInitializer()) {}
 };
 
 class Interop {
-public:
-    static void RegisterInteropTypes(v8::Local<v8::Context> context);
-    static IMP CreateMethod(const uint8_t initialParamIndex, const uint8_t argsCount, const TypeEncoding* typeEncoding, FFIMethodCallback callback, void* userData);
-    static id CallInitializer(v8::Local<v8::Context> context, const MethodMeta* methodMeta, id target, Class clazz, V8Args& args);
-    static v8::Local<v8::Value> CallFunction(ObjCMethodCall& methodCall);
-    static v8::Local<v8::Value> CallFunction(CMethodCall& methodCall);
-    static v8::Local<v8::Value> GetResultByType(v8::Local<v8::Context> context, BaseDataWrapper* typeWrapper, BaseCall* call, std::shared_ptr<v8::Persistent<v8::Value>> parentStruct = nullptr);
-    static v8::Local<v8::Value> GetResult(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, BaseCall* call, bool marshalToPrimitive, std::shared_ptr<v8::Persistent<v8::Value>> parentStruct = nullptr, bool isStructMember = false, bool ownsReturnedObject = false, bool returnsUnmanaged = false, bool isInitializer = false);
-    static void SetStructPropertyValue(v8::Local<v8::Context> context, StructWrapper* wrapper, StructField field, v8::Local<v8::Value> value);
-    static void InitializeStruct(v8::Local<v8::Context> context, void* destBuffer, std::vector<StructField> fields, v8::Local<v8::Value> inititalizer);
-    static void WriteTypeValue(v8::Local<v8::Context> context, BaseDataWrapper* typeWrapper, void* dest, v8::Local<v8::Value> arg);
-    static void WriteValue(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, void* dest, v8::Local<v8::Value> arg);
-    static id ToObject(v8::Local<v8::Context> context, v8::Local<v8::Value> arg);
-    static v8::Local<v8::Value> GetPrimitiveReturnType(v8::Local<v8::Context> context, BinaryTypeEncodingType type, BaseCall* call);
-private:
-    static void ExecuteWriteValueDebugValidationsIfInDebug(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, void* dest, v8::Local<v8::Value> arg);
-    static std::pair<IMP, ffi_closure*> CreateMethodInternal(const uint8_t initialParamIndex, const uint8_t argsCount, const TypeEncoding* typeEncoding, FFIMethodCallback callback, void* userData);
-    static CFTypeRef CreateBlock(const uint8_t initialParamIndex, const uint8_t argsCount, const TypeEncoding* typeEncoding, FFIMethodCallback callback, void* userData);
-    template <typename T>
-    static void SetStructValue(v8::Local<v8::Value> value, void* destBuffer, ptrdiff_t position);
-    static void InitializeStruct(v8::Local<v8::Context> context, void* destBuffer, std::vector<StructField> fields, v8::Local<v8::Value> inititalizer, ptrdiff_t& position);
-    static void RegisterInteropType(v8::Local<v8::Context> context, v8::Local<v8::Object> types, std::string name, PrimitiveDataWrapper* wrapper, bool autoDelete = true);
-    static void RegisterBufferFromDataFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
-    static void RegisterStringFromCString(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
-    static void RegisterHandleOfFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
-    static void RegisterAllocFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
-    static void RegisterFreeFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
-    static void RegisterAdoptFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
-    static void RegisterSizeOfFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
-    static void SetFFIParams(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, FFICall* call, const int argsCount, const int initialParameterIndex, V8Args& args);
-    static bool isRefTypeEqual(const TypeEncoding* typeEncoding,const char* clazz);
-    static v8::Local<v8::Array> ToArray(v8::Local<v8::Object> object);
-    static v8::Local<v8::Value> StructToValue(v8::Local<v8::Context> context, void* result, StructInfo structInfo, std::shared_ptr<v8::Persistent<v8::Value>> parentStruct);
-    static const TypeEncoding* CreateEncoding(BinaryTypeEncodingType type);
-    static v8::Local<v8::Value> HandleOf(v8::Local<v8::Context> context, v8::Local<v8::Value> value);
-    static v8::Local<v8::Value> CallFunctionInternal(MethodCall& methodCall);
-    static bool IsNumbericType(BinaryTypeEncodingType type);
-    static v8::Local<v8::Object> GetInteropType(v8::Local<v8::Context> context, BinaryTypeEncodingType type);
-    static std::vector<std::string> GetAdditionalProtocols(const TypeEncoding* typeEncoding);
-    static SEL GetSwizzledMethodSelector(SEL selector);
-
-    template <typename T>
-    static inline void SetValue(void* dest, T value) {
-        if (std::is_same<T, SEL>::value) {
-            memcpy(dest, &value, sizeof(SEL*));
-        } else {
-            *static_cast<T*>(dest) = value;
-        }
+ public:
+  static void RegisterInteropTypes(v8::Local<v8::Context> context);
+  static IMP CreateMethod(const uint8_t initialParamIndex,
+                          const uint8_t argsCount,
+                          const TypeEncoding* typeEncoding,
+                          FFIMethodCallback callback, void* userData);
+  static id CallInitializer(v8::Local<v8::Context> context,
+                            const MethodMeta* methodMeta, id target,
+                            Class clazz, V8Args& args);
+  static v8::Local<v8::Value> CallFunction(ObjCMethodCall& methodCall);
+  static v8::Local<v8::Value> CallFunction(CMethodCall& methodCall);
+  static v8::Local<v8::Value> GetResultByType(
+      v8::Local<v8::Context> context, BaseDataWrapper* typeWrapper,
+      BaseCall* call,
+      std::shared_ptr<v8::Persistent<v8::Value>> parentStruct = nullptr);
+  static v8::Local<v8::Value> GetResult(
+      v8::Local<v8::Context> context, const TypeEncoding* typeEncoding,
+      BaseCall* call, bool marshalToPrimitive,
+      std::shared_ptr<v8::Persistent<v8::Value>> parentStruct = nullptr,
+      bool isStructMember = false, bool ownsReturnedObject = false,
+      bool returnsUnmanaged = false, bool isInitializer = false);
+  static void SetStructPropertyValue(v8::Local<v8::Context> context,
+                                     StructWrapper* wrapper, StructField field,
+                                     v8::Local<v8::Value> value);
+  static void InitializeStruct(v8::Local<v8::Context> context, void* destBuffer,
+                               std::vector<StructField> fields,
+                               v8::Local<v8::Value> inititalizer);
+  static void WriteTypeValue(v8::Local<v8::Context> context,
+                             BaseDataWrapper* typeWrapper, void* dest,
+                             v8::Local<v8::Value> arg);
+  static void WriteValue(v8::Local<v8::Context> context,
+                         const TypeEncoding* typeEncoding, void* dest,
+                         v8::Local<v8::Value> arg);
+  static id ToObject(v8::Local<v8::Context> context, v8::Local<v8::Value> arg);
+  static v8::Local<v8::Value> GetPrimitiveReturnType(
+      v8::Local<v8::Context> context, BinaryTypeEncodingType type,
+      BaseCall* call);
+
+ private:
+  static void ExecuteWriteValueDebugValidationsIfInDebug(
+      v8::Local<v8::Context> context, const TypeEncoding* typeEncoding,
+      void* dest, v8::Local<v8::Value> arg);
+  static std::pair<IMP, ffi_closure*> CreateMethodInternal(
+      const uint8_t initialParamIndex, const uint8_t argsCount,
+      const TypeEncoding* typeEncoding, FFIMethodCallback callback,
+      void* userData);
+  static CFTypeRef CreateBlock(const uint8_t initialParamIndex,
+                               const uint8_t argsCount,
+                               const TypeEncoding* typeEncoding,
+                               FFIMethodCallback callback, void* userData);
+  template <typename T>
+  static void SetStructValue(v8::Local<v8::Value> value, void* destBuffer,
+                             ptrdiff_t position);
+  static void InitializeStruct(v8::Local<v8::Context> context, void* destBuffer,
+                               std::vector<StructField> fields,
+                               v8::Local<v8::Value> inititalizer,
+                               ptrdiff_t& position);
+  static void RegisterInteropType(v8::Local<v8::Context> context,
+                                  v8::Local<v8::Object> types, std::string name,
+                                  PrimitiveDataWrapper* wrapper,
+                                  bool autoDelete = true);
+  static void RegisterBufferFromDataFunction(v8::Local<v8::Context> context,
+                                             v8::Local<v8::Object> interop);
+  static void RegisterStringFromCString(v8::Local<v8::Context> context,
+                                        v8::Local<v8::Object> interop);
+  static void RegisterHandleOfFunction(v8::Local<v8::Context> context,
+                                       v8::Local<v8::Object> interop);
+  static void RegisterAllocFunction(v8::Local<v8::Context> context,
+                                    v8::Local<v8::Object> interop);
+  static void RegisterFreeFunction(v8::Local<v8::Context> context,
+                                   v8::Local<v8::Object> interop);
+  static void RegisterAdoptFunction(v8::Local<v8::Context> context,
+                                    v8::Local<v8::Object> interop);
+  static void RegisterSizeOfFunction(v8::Local<v8::Context> context,
+                                     v8::Local<v8::Object> interop);
+  static void RegisterEscapeExceptionFunction(v8::Local<v8::Context> context,
+                                              v8::Local<v8::Object> interop);
+  static void SetFFIParams(v8::Local<v8::Context> context,
+                           const TypeEncoding* typeEncoding, FFICall* call,
+                           const int argsCount, const int initialParameterIndex,
+                           V8Args& args);
+  static bool isRefTypeEqual(const TypeEncoding* typeEncoding,
+                             const char* clazz);
+  static v8::Local<v8::Array> ToArray(v8::Local<v8::Object> object);
+  static v8::Local<v8::Value> StructToValue(
+      v8::Local<v8::Context> context, void* result, StructInfo structInfo,
+      std::shared_ptr<v8::Persistent<v8::Value>> parentStruct);
+  static const TypeEncoding* CreateEncoding(BinaryTypeEncodingType type);
+  static v8::Local<v8::Value> HandleOf(v8::Local<v8::Context> context,
+                                       v8::Local<v8::Value> value);
+  static v8::Local<v8::Value> CallFunctionInternal(MethodCall& methodCall);
+  static bool IsNumbericType(BinaryTypeEncodingType type);
+  static v8::Local<v8::Object> GetInteropType(v8::Local<v8::Context> context,
+                                              BinaryTypeEncodingType type);
+  static std::vector<std::string> GetAdditionalProtocols(
+      const TypeEncoding* typeEncoding);
+  static SEL GetSwizzledMethodSelector(SEL selector);
+
+  template <typename T>
+  static inline void SetValue(void* dest, T value) {
+    if (std::is_same<T, SEL>::value) {
+      memcpy(dest, &value, sizeof(SEL*));
+    } else {
+      *static_cast<T*>(dest) = value;
     }
+  }
 
-    template <typename T>
-    static void SetNumericValue(void* dest, double value) {
-        if (value < std::numeric_limits<T>::lowest()) {
-            Interop::SetValue(dest, std::numeric_limits<T>::lowest());
-        } else if (value > std::numeric_limits<T>::max()) {
-            Interop::SetValue(dest, std::numeric_limits<T>::max());
-        } else {
-            Interop::SetValue(dest, (T)value);
-        }
+  template <typename T>
+  static void SetNumericValue(void* dest, double value) {
+    if (value < std::numeric_limits<T>::lowest()) {
+      Interop::SetValue(dest, std::numeric_limits<T>::lowest());
+    } else if (value > std::numeric_limits<T>::max()) {
+      Interop::SetValue(dest, std::numeric_limits<T>::max());
+    } else {
+      Interop::SetValue(dest, (T)value);
     }
+  }
+
+  typedef struct JSBlock {
+    typedef struct {
+      uintptr_t reserved;
+      uintptr_t size;
+      void (*copy)(struct JSBlock*, const struct JSBlock*);
+      void (*dispose)(struct JSBlock*);
+    } JSBlockDescriptor;
+
+    enum {
+      BLOCK_NEEDS_FREE = (1 << 24),        // runtime
+      BLOCK_HAS_COPY_DISPOSE = (1 << 25),  // compiler
+    };
+
+    void* isa;
+    volatile int32_t flags;  // contains ref count
+    int32_t reserved;
+    const void* invoke;
+    JSBlockDescriptor* descriptor;
+    void* userData;
+    ffi_closure* ffiClosure;
 
-    typedef struct JSBlock {
-        typedef struct {
-            uintptr_t reserved;
-            uintptr_t size;
-            void (*copy)(struct JSBlock*, const struct JSBlock*);
-            void (*dispose)(struct JSBlock*);
-        } JSBlockDescriptor;
-
-        enum {
-            BLOCK_NEEDS_FREE = (1 << 24), // runtime
-            BLOCK_HAS_COPY_DISPOSE = (1 << 25), // compiler
-        };
-
-        void* isa;
-        volatile int32_t flags; // contains ref count
-        int32_t reserved;
-        const void* invoke;
-        JSBlockDescriptor* descriptor;
-        void* userData;
-        ffi_closure* ffiClosure;
-        
-        static JSBlockDescriptor kJSBlockDescriptor;
-    } JSBlock;
-    
+    static JSBlockDescriptor kJSBlockDescriptor;
+  } JSBlock;
 };
 
-}
+}  // namespace tns
 
 #endif /* Interop_h */
diff --git a/NativeScript/runtime/Interop.mm b/NativeScript/runtime/Interop.mm
index 0097ef5b..47110d3a 100644
--- a/NativeScript/runtime/Interop.mm
+++ b/NativeScript/runtime/Interop.mm
@@ -618,23 +618,25 @@ inline bool isBool() {
     if (wrapper != nullptr) {
       if (wrapper->Type() == WrapperType::Enum) {
         EnumDataWrapper* enumWrapper = static_cast<EnumDataWrapper*>(wrapper);
-        Local<Context> context = isolate->GetCurrentContext();
-        std::string jsCode = enumWrapper->JSCode();
-        Local<Script> script;
-        if (!Script::Compile(context, tns::ToV8String(isolate, jsCode)).ToLocal(&script)) {
-          tns::Assert(false, isolate);
-        }
-        tns::Assert(!script.IsEmpty(), isolate);
+        if (!enumWrapper->HasCachedValue()) {
+          Local<Context> context = isolate->GetCurrentContext();
+          std::string jsCode = enumWrapper->JSCode();
+          Local<Script> script;
+          if (!Script::Compile(context, tns::ToV8String(isolate, jsCode)).ToLocal(&script)) {
+            tns::Assert(false, isolate);
+          }
+          tns::Assert(!script.IsEmpty(), isolate);
 
-        Local<Value> result;
-        if (!script->Run(context).ToLocal(&result) && !result.IsEmpty()) {
-          tns::Assert(false, isolate);
-        }
+          Local<Value> result;
+          if (!script->Run(context).ToLocal(&result) && !result.IsEmpty()) {
+            tns::Assert(false, isolate);
+          }
 
-        tns::Assert(result->IsNumber(), isolate);
+          tns::Assert(result->IsNumber(), isolate);
 
-        double value = result.As<Number>()->Value();
-        SetValue(dest, value);
+          enumWrapper->SetCachedValue(result.As<Number>()->Value());
+        }
+        SetValue(dest, enumWrapper->CachedValue());
       } else if (wrapper->Type() == WrapperType::Pointer) {
         PointerWrapper* pointerWrapper = static_cast<PointerWrapper*>(wrapper);
         void* data = pointerWrapper->Data();
@@ -1651,8 +1653,45 @@ inline bool isBool() {
     ffi_call(parametrizedCall->Cif, FFI_FN(methodCall.functionPointer_), call.ResultBuffer(),
              call.ArgsArray());
   } @catch (NSException* e) {
-    std::string message = [[e description] UTF8String];
-    throw NativeScriptException(message);
+    // Preserve the original NSException: build a JS Error carrying its name and
+    // reason, and attach the wrapped native object as `nativeException` (mirrors
+    // the NSError-out path below). Throw it via NativeScriptException so the JS
+    // catch handler receives exactly this object.
+    Isolate* isolate = methodCall.context_->GetIsolate();
+    Local<Context> context = isolate->GetCurrentContext();
+
+    NSString* nsName = [e name];
+    NSString* nsReason = [e reason];
+    std::string message =
+        nsReason ? [nsReason UTF8String] : (nsName ? [nsName UTF8String] : "NSException");
+
+    Local<Value> jsErrVal = Exception::Error(tns::ToV8String(isolate, message));
+    if (jsErrVal.IsEmpty() || !jsErrVal->IsObject()) {
+      // Fallback: keep the description-only behavior if Error creation fails.
+      throw NativeScriptException([[e description] UTF8String]);
+    }
+
+    Local<Object> jsErrObj = jsErrVal.As<Object>();
+    if (nsName != nil) {
+      jsErrObj
+          ->Set(context, tns::ToV8String(isolate, "name"),
+                tns::ToV8String(isolate, [nsName UTF8String]))
+          .FromMaybe(false);
+    }
+    if (nsReason != nil) {
+      jsErrObj
+          ->Set(context, tns::ToV8String(isolate, "message"),
+                tns::ToV8String(isolate, [nsReason UTF8String]))
+          .FromMaybe(false);
+    }
+
+    ObjCDataWrapper* wrapper = new ObjCDataWrapper((id)e);
+    Local<Value> nativeWrapper =
+        ArgConverter::CreateJsWrapper(context, wrapper, Local<Object>(), true);
+    jsErrObj->Set(context, tns::ToV8String(isolate, "nativeException"), nativeWrapper)
+        .FromMaybe(false);
+
+    throw NativeScriptException(isolate, jsErrObj.As<Value>(), message);
   }
 
   if (errorRef != nullptr) {
diff --git a/NativeScript/runtime/InteropTypes.mm b/NativeScript/runtime/InteropTypes.mm
index 10758dc2..b376e01f 100644
--- a/NativeScript/runtime/InteropTypes.mm
+++ b/NativeScript/runtime/InteropTypes.mm
@@ -1,4 +1,5 @@
 #include <Foundation/Foundation.h>
+#include "ArgConverter.h"
 #include "Caches.h"
 #include "Constants.h"
 #include "FunctionReference.h"
@@ -31,6 +32,7 @@
   RegisterFreeFunction(context, interop);
   RegisterAdoptFunction(context, interop);
   RegisterSizeOfFunction(context, interop);
+  RegisterEscapeExceptionFunction(context, interop);
 
   RegisterInteropType(
       context, types, "noop",
@@ -330,6 +332,156 @@ new PrimitiveDataWrapper(sizeof(void*),
   tns::Assert(success, isolate);
 }
 
+// Returns the wrapped NSException value carried by `value` — either `value`
+// itself when it wraps an NSException, or its `.nativeException` when `value` is
+// an Error carrying a wrapped NSException. Empty handle otherwise.
+static Local<Value> GetWrappedNSException(Local<Context> context, Local<Value> value) {
+  Isolate* isolate = context->GetIsolate();
+  auto isWrappedNSException = [&](Local<Value> v) -> bool {
+    if (v.IsEmpty() || !v->IsObject()) {
+      return false;
+    }
+    BaseDataWrapper* wrapper = tns::GetValue(isolate, v);
+    if (wrapper == nullptr || wrapper->Type() != WrapperType::ObjCObject) {
+      return false;
+    }
+    id data = static_cast<ObjCDataWrapper*>(wrapper)->Data();
+    return [data isKindOfClass:[NSException class]];
+  };
+
+  if (isWrappedNSException(value)) {
+    return value;
+  }
+  if (value->IsObject()) {
+    Local<Value> nativeExc;
+    if (value.As<Object>()
+            ->Get(context, tns::ToV8String(isolate, "nativeException"))
+            .ToLocal(&nativeExc) &&
+        isWrappedNSException(nativeExc)) {
+      return nativeExc;
+    }
+  }
+  return Local<Value>();
+}
+
+void Interop::RegisterEscapeExceptionFunction(Local<Context> context, Local<Object> interop) {
+  Local<v8::Function> func;
+  bool success =
+      v8::Function::New(context, [](const FunctionCallbackInfo<Value>& info) {
+        Isolate* isolate = info.GetIsolate();
+        Local<Context> context = isolate->GetCurrentContext();
+
+        if (info.Length() < 1) {
+          isolate->ThrowException(Exception::TypeError(tns::ToV8String(
+              isolate, "interop.escapeException requires 1 argument, but only 0 present.")));
+          return;
+        }
+
+        Local<Value> x = info[0];
+        Local<Private> brand = ArgConverter::GetEscapeExceptionBrand(isolate);
+
+        // Idempotent: an already-branded value is returned unchanged.
+        if (!brand.IsEmpty() && x->IsObject()) {
+          Maybe<bool> hasBrand = x.As<Object>()->HasPrivate(context, brand);
+          if (hasBrand.IsJust() && hasBrand.FromJust()) {
+            info.GetReturnValue().Set(x);
+            return;
+          }
+        }
+
+        // Derive the message string, preferring x.message when x is an Error.
+        std::string message;
+        bool xIsObject = x->IsObject();
+        if (xIsObject) {
+          Local<Value> msgVal;
+          if (x.As<Object>()->Get(context, tns::ToV8String(isolate, "message")).ToLocal(&msgVal) &&
+              !msgVal->IsNullOrUndefined()) {
+            message = tns::ToString(isolate, msgVal);
+          } else {
+            message = tns::ToString(isolate, x);
+          }
+        } else {
+          message = tns::ToString(isolate, x);
+        }
+
+        // The returned value is a real JS Error so `throw interop.escapeException(x)`
+        // behaves like a normal throw in pure-JS paths.
+        Local<Value> errVal = Exception::Error(tns::ToV8String(isolate, message));
+        Local<Object> errObj = errVal.As<Object>();
+
+        // Copy stack from x when it is an Error carrying one.
+        std::string stack;
+        if (xIsObject) {
+          Local<Value> stackVal;
+          if (x.As<Object>()->Get(context, tns::ToV8String(isolate, "stack")).ToLocal(&stackVal) &&
+              stackVal->IsString()) {
+            stack = tns::ToString(isolate, stackVal);
+            errObj->Set(context, tns::ToV8String(isolate, "stack"), stackVal).FromMaybe(false);
+          }
+        }
+
+        // Capture the escape-site JS stack: where interop.escapeException was
+        // called, distinct from the origin stack of the error being wrapped.
+        std::string escapeStack = NativeScriptException::GetErrorStackTrace(
+            isolate, v8::StackTrace::CurrentStackTrace(isolate, 100, v8::StackTrace::kOverview));
+
+        // Build the branded payload: the original NSException when x carries one,
+        // otherwise synthesis info (name/message/stack). The escape-site stack
+        // always travels along, in both shapes.
+        Local<Object> payload = Object::New(isolate);
+        payload
+            ->Set(context, tns::ToV8String(isolate, "escapeStack"),
+                  tns::ToV8String(isolate, escapeStack))
+            .FromMaybe(false);
+        Local<Value> nativeExc = GetWrappedNSException(context, x);
+        if (!nativeExc.IsEmpty()) {
+          payload->Set(context, tns::ToV8String(isolate, "nativeException"), nativeExc)
+              .FromMaybe(false);
+          // Also carry the JS origin/propagation stack of the error that wrapped
+          // the native exception, when present.
+          if (!stack.empty()) {
+            payload
+                ->Set(context, tns::ToV8String(isolate, "stack"), tns::ToV8String(isolate, stack))
+                .FromMaybe(false);
+          }
+        } else {
+          std::string name = "Error";
+          if (xIsObject) {
+            Local<Value> nameVal;
+            if (x.As<Object>()->Get(context, tns::ToV8String(isolate, "name")).ToLocal(&nameVal) &&
+                nameVal->IsString()) {
+              name = tns::ToString(isolate, nameVal);
+            }
+          }
+          payload->Set(context, tns::ToV8String(isolate, "name"), tns::ToV8String(isolate, name))
+              .FromMaybe(false);
+          payload
+              ->Set(context, tns::ToV8String(isolate, "message"), tns::ToV8String(isolate, message))
+              .FromMaybe(false);
+          // When x is a non-Error (no .stack, e.g. a plain string) fall back to
+          // the escape-site stack so a stack always travels with the escape.
+          const std::string& synthStack = stack.empty() ? escapeStack : stack;
+          payload
+              ->Set(context, tns::ToV8String(isolate, "stack"),
+                    tns::ToV8String(isolate, synthStack))
+              .FromMaybe(false);
+        }
+
+        if (!brand.IsEmpty()) {
+          errObj->SetPrivate(context, brand, payload).FromMaybe(false);
+        }
+
+        info.GetReturnValue().Set(errObj);
+      }).ToLocal(&func);
+
+  Isolate* isolate = context->GetIsolate();
+  tns::Assert(success, isolate);
+
+  success =
+      interop->Set(context, tns::ToV8String(isolate, "escapeException"), func).FromMaybe(false);
+  tns::Assert(success, isolate);
+}
+
 void Interop::RegisterFreeFunction(Local<Context> context, Local<Object> interop) {
   Local<v8::Function> func;
   bool success = v8::Function::New(context, [](const FunctionCallbackInfo<Value>& info) {
diff --git a/NativeScript/runtime/MetadataBuilder.h b/NativeScript/runtime/MetadataBuilder.h
index 8c0470f9..6d281ac4 100644
--- a/NativeScript/runtime/MetadataBuilder.h
+++ b/NativeScript/runtime/MetadataBuilder.h
@@ -1,72 +1,155 @@
 #ifndef MetadataBuilder_h
 #define MetadataBuilder_h
 
-#include "robin_hood.h"
-#include "libffi.h"
-#include "Common.h"
-#include "Metadata.h"
 #include "ClassBuilder.h"
+#include "Common.h"
 #include "DataWrapper.h"
+#include "Metadata.h"
+#include "libffi.h"
+#include "robin_hood.h"
 
 namespace tns {
 
 class MetadataBuilder {
-public:
-    static void RegisterConstantsOnGlobalObject(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate, bool isWorkerThread);
-    static v8::Local<v8::FunctionTemplate> GetOrCreateConstructorFunctionTemplate(v8::Local<v8::Context> context, const BaseClassMeta* meta, KnownUnknownClassPair pair, const std::vector<std::string>& additionalProtocols = std::vector<std::string>());
-    static v8::Local<v8::Function> GetOrCreateStructCtorFunction(v8::Local<v8::Context> context, StructInfo structInfo);
-    static void StructPropertyGetterCallback(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value>& info);
-    static void StructPropertySetterCallback(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info);
-private:
-    static v8::Local<v8::FunctionTemplate> GetOrCreateConstructorFunctionTemplateInternal(v8::Local<v8::Context> context, const BaseClassMeta* meta, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& instanceMembers, robin_hood::unordered_map<std::string, uint8_t>& staticMembers, const std::vector<std::string>& additionalProtocols = std::vector<std::string>());
-    static void GlobalPropertyGetter(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value>& info);
-    static void ClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void AllocCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void CFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void PropertyGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void PropertySetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void PropertyNameGetterCallback(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value> &info);
-    static void PropertyNameSetterCallback(v8::Local<v8::Name> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void> &info);
-    static void StructConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void StructEqualsCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void ToStringFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static std::pair<ffi_type*, void*> GetStructData(v8::Local<v8::Context> context, v8::Local<v8::Object> initializer, StructInfo structInfo);
+ public:
+  static void RegisterConstantsOnGlobalObject(
+      v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate,
+      bool isWorkerThread);
+  static v8::Local<v8::FunctionTemplate> GetOrCreateConstructorFunctionTemplate(
+      v8::Local<v8::Context> context, const BaseClassMeta* meta,
+      KnownUnknownClassPair pair,
+      const std::vector<std::string>& additionalProtocols =
+          std::vector<std::string>());
+  static v8::Local<v8::Function> GetOrCreateStructCtorFunction(
+      v8::Local<v8::Context> context, StructInfo structInfo);
+  static void StructPropertyGetterCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void StructPropertySetterCallback(
+      v8::Local<v8::Name> property, v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+
+ private:
+  static v8::Local<v8::FunctionTemplate>
+  GetOrCreateConstructorFunctionTemplateInternal(
+      v8::Local<v8::Context> context, const BaseClassMeta* meta,
+      KnownUnknownClassPair pair,
+      robin_hood::unordered_map<std::string, uint8_t>& instanceMembers,
+      robin_hood::unordered_map<std::string, uint8_t>& staticMembers,
+      const std::vector<std::string>& additionalProtocols =
+          std::vector<std::string>());
+  static void GlobalPropertyGetter(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void ClassConstructorCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void AllocCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void CFunctionCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void PropertyGetterCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void PropertySetterCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void PropertyNameGetterCallback(
+      v8::Local<v8::Name> name,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void PropertyNameSetterCallback(
+      v8::Local<v8::Name> name, v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<void>& info);
+  static void StructConstructorCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void StructEqualsCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void ToStringFunctionCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  static std::pair<ffi_type*, void*> GetStructData(
+      v8::Local<v8::Context> context, v8::Local<v8::Object> initializer,
+      StructInfo structInfo);
 
-    static v8::Local<v8::Value> InvokeMethod(v8::Local<v8::Context> context, const MethodMeta* meta, v8::Local<v8::Object> receiver, V8Args& args, std::string containingClass, bool isMethodCallback);
-    static void RegisterAllocMethod(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, const InterfaceMeta* interfaceMeta);
-    static void RegisterInstanceMethods(v8::Local<v8::Context> context, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
-    static void RegisterInstanceProperties(v8::Local<v8::Context> context, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta, std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
-    static void RegisterInstanceProtocols(v8::Local<v8::Context> context, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta, std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
-    static void RegisterAdditionalProtocols(v8::Local<v8::Context> context, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, KnownUnknownClassPair pair, const std::vector<std::string>& additionalProtocols, robin_hood::unordered_map<std::string, uint8_t>& names);
-    static void RegisterStaticMethods(v8::Local<v8::Context> context, v8::Local<v8::Function> ctorFunc, const BaseClassMeta* meta, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
-    static void RegisterStaticProperties(v8::Local<v8::Context> context, v8::Local<v8::Function> ctorFunc, const BaseClassMeta* meta, const std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
-    static void RegisterStaticProtocols(v8::Local<v8::Context> context, v8::Local<v8::Function> ctorFunc, const BaseClassMeta* meta, const std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
-    static void DefineFunctionLengthProperty(v8::Local<v8::Context> context, const TypeEncodingsList<ArrayCount>* encodings, v8::Local<v8::Function> func);
+  static v8::Local<v8::Value> InvokeMethod(v8::Local<v8::Context> context,
+                                           const MethodMeta* meta,
+                                           v8::Local<v8::Object> receiver,
+                                           V8Args& args,
+                                           std::string containingClass,
+                                           bool isMethodCallback);
+  static void RegisterAllocMethod(
+      v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> ctorFuncTemplate,
+      const InterfaceMeta* interfaceMeta);
+  static void RegisterInstanceMethods(
+      v8::Local<v8::Context> context,
+      v8::Local<v8::FunctionTemplate> ctorFuncTemplate,
+      const BaseClassMeta* meta, KnownUnknownClassPair pair,
+      robin_hood::unordered_map<std::string, uint8_t>& names);
+  static void RegisterInstanceProperties(
+      v8::Local<v8::Context> context,
+      v8::Local<v8::FunctionTemplate> ctorFuncTemplate,
+      const BaseClassMeta* meta, std::string className,
+      KnownUnknownClassPair pair,
+      robin_hood::unordered_map<std::string, uint8_t>& names);
+  static void RegisterInstanceProtocols(
+      v8::Local<v8::Context> context,
+      v8::Local<v8::FunctionTemplate> ctorFuncTemplate,
+      const BaseClassMeta* meta, std::string className,
+      KnownUnknownClassPair pair,
+      robin_hood::unordered_map<std::string, uint8_t>& names);
+  static void RegisterAdditionalProtocols(
+      v8::Local<v8::Context> context,
+      v8::Local<v8::FunctionTemplate> ctorFuncTemplate,
+      KnownUnknownClassPair pair,
+      const std::vector<std::string>& additionalProtocols,
+      robin_hood::unordered_map<std::string, uint8_t>& names);
+  static void RegisterStaticMethods(
+      v8::Local<v8::Context> context, v8::Local<v8::Function> ctorFunc,
+      const BaseClassMeta* meta, KnownUnknownClassPair pair,
+      robin_hood::unordered_map<std::string, uint8_t>& names);
+  static void RegisterStaticProperties(
+      v8::Local<v8::Context> context, v8::Local<v8::Function> ctorFunc,
+      const BaseClassMeta* meta, const std::string className,
+      KnownUnknownClassPair pair,
+      robin_hood::unordered_map<std::string, uint8_t>& names);
+  static void RegisterStaticProtocols(
+      v8::Local<v8::Context> context, v8::Local<v8::Function> ctorFunc,
+      const BaseClassMeta* meta, const std::string className,
+      KnownUnknownClassPair pair,
+      robin_hood::unordered_map<std::string, uint8_t>& names);
+  static void DefineFunctionLengthProperty(
+      v8::Local<v8::Context> context,
+      const TypeEncodingsList<ArrayCount>* encodings,
+      v8::Local<v8::Function> func);
 
-    static void SwizzledInstanceMethodCallback(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info);
-    static void SwizzledPropertyCallback(v8::Local<v8::Name> property, const v8::PropertyDescriptor& desc, const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void SwizzledInstanceMethodCallback(
+      v8::Local<v8::Name> property, v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void SwizzledPropertyCallback(
+      v8::Local<v8::Name> property, const v8::PropertyDescriptor& desc,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
 
-    struct GlobalHandlerContext {
-        GlobalHandlerContext(bool isWorkerThread): isWorkerThread_(isWorkerThread) {
-        }
-        bool isWorkerThread_;
-    };
+  struct GlobalHandlerContext {
+    GlobalHandlerContext(bool isWorkerThread)
+        : isWorkerThread_(isWorkerThread) {}
+    bool isWorkerThread_;
+    // Name currently being defined as a real own property on the global from
+    // inside GlobalPropertyGetter. CreateDataProperty performs a lookup that
+    // re-enters the (kNonMasking) interceptor before the property exists, so
+    // the getter must decline for this name to avoid infinite recursion.
+    std::string definingProperty_;
+  };
 
-    template<class T>
-    struct CacheItem {
-        CacheItem(const T* meta, const std::string className, void* userData = nullptr)
-        : meta_(meta),
-          className_(className),
-          userData_(userData) {
-            static_assert(std::is_base_of<Meta, T>::value, "Derived not derived from Meta");
-        }
-        const T* meta_;
-        const std::string className_;
-        void* userData_;
-    };
+  template <class T>
+  struct CacheItem {
+    CacheItem(const T* meta, const std::string className,
+              void* userData = nullptr)
+        : meta_(meta), className_(className), userData_(userData) {
+      static_assert(std::is_base_of<Meta, T>::value,
+                    "Derived not derived from Meta");
+    }
+    const T* meta_;
+    const std::string className_;
+    void* userData_;
+  };
 };
 
-}
+}  // namespace tns
 
 #endif /* MetadataBuilder_h */
diff --git a/NativeScript/runtime/MetadataBuilder.mm b/NativeScript/runtime/MetadataBuilder.mm
index b7c296fd..89333ef5 100644
--- a/NativeScript/runtime/MetadataBuilder.mm
+++ b/NativeScript/runtime/MetadataBuilder.mm
@@ -1,1049 +1,1229 @@
-#include <Foundation/Foundation.h>
 #include "MetadataBuilder.h"
-#include "NativeScriptException.h"
+#include <Foundation/Foundation.h>
 #include "ArgConverter.h"
-#include "ObjectManager.h"
-#include "InlineFunctions.h"
-#include "SymbolLoader.h"
+#include "Caches.h"
 #include "Constants.h"
 #include "Helpers.h"
+#include "InlineFunctions.h"
 #include "Interop.h"
-#include "Worker.h"
-#include "Caches.h"
-#include "Tasks.h"
+#include "NativeScriptException.h"
+#include "ObjectManager.h"
 #include "Runtime.h"
 #include "RuntimeConfig.h"
+#include "SymbolLoader.h"
+#include "Tasks.h"
+#include "Worker.h"
 
 using namespace v8;
 
 namespace tns {
 
-void MetadataBuilder::RegisterConstantsOnGlobalObject(Isolate* isolate, Local<ObjectTemplate> globalTemplate, bool isWorkerThread) {
-    GlobalHandlerContext* handlerContext = new GlobalHandlerContext(isWorkerThread);
-    Caches::Get(isolate)->registerCacheBoundObject(handlerContext);
-    Local<External> ext = External::New(isolate, handlerContext);
-
-    NamedPropertyHandlerConfiguration config(MetadataBuilder::GlobalPropertyGetter, nullptr, nullptr, nullptr, nullptr, ext, PropertyHandlerFlags::kNonMasking);
-    globalTemplate->SetHandler(config);
+void MetadataBuilder::RegisterConstantsOnGlobalObject(Isolate* isolate,
+                                                      Local<ObjectTemplate> globalTemplate,
+                                                      bool isWorkerThread) {
+  GlobalHandlerContext* handlerContext = new GlobalHandlerContext(isWorkerThread);
+  Caches::Get(isolate)->registerCacheBoundObject(handlerContext);
+  Local<External> ext = External::New(isolate, handlerContext);
+
+  NamedPropertyHandlerConfiguration config(MetadataBuilder::GlobalPropertyGetter, nullptr, nullptr,
+                                           nullptr, nullptr, ext,
+                                           PropertyHandlerFlags::kNonMasking);
+  globalTemplate->SetHandler(config);
 }
 
-void MetadataBuilder::GlobalPropertyGetter(Local<v8::Name> property, const PropertyCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    std::string propName = tns::ToString(isolate, property);
-
-    GlobalHandlerContext* ctx = static_cast<GlobalHandlerContext*>(info.Data().As<External>()->Value());
-
-    if (ctx->isWorkerThread_ && std::find(Worker::GlobalFunctions.begin(), Worker::GlobalFunctions.end(), propName) != Worker::GlobalFunctions.end()) {
-        return;
+void MetadataBuilder::GlobalPropertyGetter(Local<v8::Name> property,
+                                           const PropertyCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  std::string propName = tns::ToString(isolate, property);
+
+  GlobalHandlerContext* ctx =
+      static_cast<GlobalHandlerContext*>(info.Data().As<External>()->Value());
+
+  // Decline while this exact name is being defined as an own property below —
+  // CreateDataProperty's lookup re-enters this interceptor before the property
+  // exists on the global.
+  if (ctx->definingProperty_ == propName && !propName.empty()) {
+    return;
+  }
+
+  if (ctx->isWorkerThread_ &&
+      std::find(Worker::GlobalFunctions.begin(), Worker::GlobalFunctions.end(), propName) !=
+          Worker::GlobalFunctions.end()) {
+    return;
+  }
+
+  if (InlineFunctions::IsGlobalFunction(propName)) {
+    return;
+  }
+
+  const Meta* meta = ArgConverter::GetMeta(propName);
+  if (meta == nullptr || !meta->isAvailable()) {
+    return;
+  }
+
+  Local<Context> context = isolate->GetCurrentContext();
+
+  if (meta->type() == MetaType::Interface || meta->type() == MetaType::ProtocolType) {
+    const BaseClassMeta* classMeta = static_cast<const BaseClassMeta*>(meta);
+    Class knownClass = meta->type() == MetaType::Interface ? objc_getClass(meta->name()) : nil;
+    KnownUnknownClassPair pair(knownClass);
+    MetadataBuilder::GetOrCreateConstructorFunctionTemplate(context, classMeta, pair);
+
+    bool isInterface = meta->type() == MetaType::Interface;
+    std::string name = meta->name();
+    std::shared_ptr<Caches> cache = Caches::Get(isolate);
+    if (isInterface) {
+      auto it = cache->CtorFuncs.find(name);
+      if (it != cache->CtorFuncs.end()) {
+        Local<v8::Function> func = it->second->Get(isolate);
+        info.GetReturnValue().Set(func);
+      }
+    } else {
+      auto it = cache->ProtocolCtorFuncs.find(name);
+      if (it != cache->ProtocolCtorFuncs.end()) {
+        Local<v8::Function> func = it->second->Get(isolate);
+        info.GetReturnValue().Set(func);
+      }
     }
-
-    if (InlineFunctions::IsGlobalFunction(propName)) {
-        return;
+  } else if (meta->type() == MetaType::Function) {
+    auto cache = Caches::Get(isolate);
+    std::string funcName = meta->name();
+    auto it = cache->CFunctions.find(funcName);
+    if (it != cache->CFunctions.end()) {
+      Local<v8::Function> func = it->second->Get(isolate);
+      info.GetReturnValue().Set(func);
+      return;
     }
 
-    const Meta* meta = ArgConverter::GetMeta(propName);
-    if (meta == nullptr || !meta->isAvailable()) {
-        return;
+    const FunctionMeta* funcMeta = static_cast<const FunctionMeta*>(meta);
+    void* functionPointer =
+        SymbolLoader::instance().loadFunctionSymbol(meta->topLevelModule(), meta->name());
+    if (functionPointer == nullptr) {
+      Log(@"Unable to load \"%s\" function", meta->name());
+      tns::Assert(false, isolate);
     }
 
-    Local<Context> context = isolate->GetCurrentContext();
-
-    if (meta->type() == MetaType::Interface || meta->type() == MetaType::ProtocolType) {
-        const BaseClassMeta* classMeta = static_cast<const BaseClassMeta*>(meta);
-        Class knownClass = meta->type() == MetaType::Interface ? objc_getClass(meta->name()) : nil;
-        KnownUnknownClassPair pair(knownClass);
-        MetadataBuilder::GetOrCreateConstructorFunctionTemplate(context, classMeta, pair);
-
-        bool isInterface = meta->type() == MetaType::Interface;
-        std::string name = meta->name();
-        std::shared_ptr<Caches> cache = Caches::Get(isolate);
-        if (isInterface) {
-            auto it = cache->CtorFuncs.find(name);
-            if (it != cache->CtorFuncs.end()) {
-                Local<v8::Function> func = it->second->Get(isolate);
-                info.GetReturnValue().Set(func);
-            }
-        } else {
-            auto it = cache->ProtocolCtorFuncs.find(name);
-            if (it != cache->ProtocolCtorFuncs.end()) {
-                Local<v8::Function> func = it->second->Get(isolate);
-                info.GetReturnValue().Set(func);
-            }
-        }
-    } else if (meta->type() == MetaType::Function) {
-        auto cache = Caches::Get(isolate);
-        std::string funcName = meta->name();
-        auto it = cache->CFunctions.find(funcName);
-        if (it != cache->CFunctions.end()) {
-            Local<v8::Function> func = it->second->Get(isolate);
-            info.GetReturnValue().Set(func);
-            return;
-        }
+    CacheItem<FunctionMeta>* item =
+        new CacheItem<FunctionMeta>(funcMeta, std::string(), functionPointer);
+    Caches::Get(isolate)->registerCacheBoundObject(item);
+    Local<External> ext = External::New(isolate, item);
+    Local<v8::Function> func;
+    bool success = v8::Function::New(context, CFunctionCallback, ext).ToLocal(&func);
+    tns::Assert(success, isolate);
 
-        const FunctionMeta* funcMeta = static_cast<const FunctionMeta*>(meta);
-        void* functionPointer = SymbolLoader::instance().loadFunctionSymbol(meta->topLevelModule(), meta->name());
-        if (functionPointer == nullptr) {
-            Log(@"Unable to load \"%s\" function", meta->name());
-            tns::Assert(false, isolate);
-        }
+    tns::SetValue(isolate, func, new FunctionWrapper(funcMeta));
+    MetadataBuilder::DefineFunctionLengthProperty(context, funcMeta->encodings(), func);
 
-        CacheItem<FunctionMeta>* item = new CacheItem<FunctionMeta>(funcMeta, std::string(), functionPointer);
-        Caches::Get(isolate)->registerCacheBoundObject(item);
-        Local<External> ext = External::New(isolate, item);
-        Local<v8::Function> func;
-        bool success = v8::Function::New(context, CFunctionCallback, ext).ToLocal(&func);
-        tns::Assert(success, isolate);
+    auto uniquePersistent = std::make_unique<Persistent<v8::Function>>(isolate, func);
+    uniquePersistent->SetWrapperClassId(Constants::ClassTypes::DataWrapper);
+    cache->CFunctions.emplace(funcName, std::move(uniquePersistent));
 
-        tns::SetValue(isolate, func, new FunctionWrapper(funcMeta));
-        MetadataBuilder::DefineFunctionLengthProperty(context, funcMeta->encodings(), func);
+    info.GetReturnValue().Set(func);
+  } else if (meta->type() == MetaType::Var) {
+    void* dataSymbol =
+        SymbolLoader::instance().loadDataSymbol(meta->topLevelModule(), meta->name());
+    if (!dataSymbol) {
+      return;
+    }
 
-        auto uniquePersistent = std::make_unique<Persistent<v8::Function>>(isolate, func);
-        uniquePersistent->SetWrapperClassId(Constants::ClassTypes::DataWrapper);
-        cache->CFunctions.emplace(funcName, std::move(uniquePersistent));
+    const VarMeta* varMeta = static_cast<const VarMeta*>(meta);
 
-        info.GetReturnValue().Set(func);
-    } else if (meta->type() == MetaType::Var) {
-        void* dataSymbol = SymbolLoader::instance().loadDataSymbol(meta->topLevelModule(), meta->name());
-        if (!dataSymbol) {
-            return;
-        }
-
-        const VarMeta* varMeta = static_cast<const VarMeta*>(meta);
-
-        BaseCall bc((uint8_t*)dataSymbol);
-        const TypeEncoding* typeEncoding = varMeta->encoding();
-        Local<Value> result = Interop::GetResult(context, typeEncoding, &bc, true);
-        info.GetReturnValue().Set(result);
-    } else if (meta->type() == MetaType::JsCode) {
-        const JsCodeMeta* jsCodeMeta = static_cast<const JsCodeMeta*>(meta);
-        std::string jsCode = jsCodeMeta->jsCode();
-        Local<Script> script;
-        if (!Script::Compile(context, tns::ToV8String(isolate, jsCode)).ToLocal(&script)) {
-            tns::Assert(false, isolate);
-        }
-        tns::Assert(!script.IsEmpty(), isolate);
+    BaseCall bc((uint8_t*)dataSymbol);
+    const TypeEncoding* typeEncoding = varMeta->encoding();
+    Local<Value> result = Interop::GetResult(context, typeEncoding, &bc, true);
+    info.GetReturnValue().Set(result);
+  } else if (meta->type() == MetaType::JsCode) {
+    const JsCodeMeta* jsCodeMeta = static_cast<const JsCodeMeta*>(meta);
+    std::string jsCode = jsCodeMeta->jsCode();
+    Local<Script> script;
+    if (!Script::Compile(context, tns::ToV8String(isolate, jsCode)).ToLocal(&script)) {
+      tns::Assert(false, isolate);
+    }
+    tns::Assert(!script.IsEmpty(), isolate);
 
-        Local<Value> result;
-        if (!script->Run(context).ToLocal(&result)) {
-            tns::Assert(false, isolate);
-        }
-        info.GetReturnValue().Set(result);
-    } else if (meta->type() == MetaType::Struct) {
-        const StructMeta* structMeta = static_cast<const StructMeta*>(meta);
-        StructInfo structInfo = FFICall::GetStructInfo(structMeta);
-        Local<v8::Function> structCtorFunc = MetadataBuilder::GetOrCreateStructCtorFunction(context, structInfo);
-        info.GetReturnValue().Set(structCtorFunc);
+    Local<Value> result;
+    if (!script->Run(context).ToLocal(&result)) {
+      tns::Assert(false, isolate);
     }
+    // Memoize the evaluated value as a real own property: the interceptor is
+    // registered kNonMasking, so later reads of this global bypass it (and the
+    // per-access recompilation of the meta's JS snippet) entirely.
+    ctx->definingProperty_ = propName;
+    bool memoized =
+        context->Global()->CreateDataProperty(context, property, result).FromMaybe(false);
+    (void)memoized;
+    ctx->definingProperty_.clear();
+    info.GetReturnValue().Set(result);
+  } else if (meta->type() == MetaType::Struct) {
+    const StructMeta* structMeta = static_cast<const StructMeta*>(meta);
+    StructInfo structInfo = FFICall::GetStructInfo(structMeta);
+    Local<v8::Function> structCtorFunc =
+        MetadataBuilder::GetOrCreateStructCtorFunction(context, structInfo);
+    info.GetReturnValue().Set(structCtorFunc);
+  }
 }
 
-Local<v8::Function> MetadataBuilder::GetOrCreateStructCtorFunction(Local<Context> context, StructInfo structInfo) {
-    Isolate* isolate = context->GetIsolate();
-    auto cache = Caches::Get(isolate);
-    auto it = cache->StructConstructorFunctions.find(structInfo.Name());
-    if (it != cache->StructConstructorFunctions.end()) {
-        return it->second->Get(isolate);
-    }
+Local<v8::Function> MetadataBuilder::GetOrCreateStructCtorFunction(Local<Context> context,
+                                                                   StructInfo structInfo) {
+  Isolate* isolate = context->GetIsolate();
+  auto cache = Caches::Get(isolate);
+  auto it = cache->StructConstructorFunctions.find(structInfo.Name());
+  if (it != cache->StructConstructorFunctions.end()) {
+    return it->second->Get(isolate);
+  }
 
-    StructTypeWrapper* wrapper = new StructTypeWrapper(structInfo);
-    Local<External> ext = External::New(isolate, wrapper);
-    Local<v8::Function> structCtorFunc;
-    bool success = v8::Function::New(context, StructConstructorCallback, ext).ToLocal(&structCtorFunc);
-    tns::Assert(success, isolate);
+  StructTypeWrapper* wrapper = new StructTypeWrapper(structInfo);
+  Local<External> ext = External::New(isolate, wrapper);
+  Local<v8::Function> structCtorFunc;
+  bool success =
+      v8::Function::New(context, StructConstructorCallback, ext).ToLocal(&structCtorFunc);
+  tns::Assert(success, isolate);
 
-    tns::SetValue(isolate, structCtorFunc, wrapper);
+  tns::SetValue(isolate, structCtorFunc, wrapper);
 
-    Local<v8::Function> equalsFunc;
-    success = v8::Function::New(context, StructEqualsCallback).ToLocal(&equalsFunc);
-    tns::Assert(success, isolate);
+  Local<v8::Function> equalsFunc;
+  success = v8::Function::New(context, StructEqualsCallback).ToLocal(&equalsFunc);
+  tns::Assert(success, isolate);
 
-    success = structCtorFunc->Set(context, tns::ToV8String(isolate, "equals"), equalsFunc).FromMaybe(false);
-    tns::Assert(success, isolate);
+  success =
+      structCtorFunc->Set(context, tns::ToV8String(isolate, "equals"), equalsFunc).FromMaybe(false);
+  tns::Assert(success, isolate);
 
-    cache->StructConstructorFunctions.emplace(structInfo.Name(), std::make_unique<Persistent<v8::Function>>(isolate, structCtorFunc));
+  cache->StructConstructorFunctions.emplace(
+      structInfo.Name(), std::make_unique<Persistent<v8::Function>>(isolate, structCtorFunc));
 
-    return structCtorFunc;
+  return structCtorFunc;
 }
 
 void MetadataBuilder::StructConstructorCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    Local<Context> context = isolate->GetCurrentContext();
-    try {
-        StructTypeWrapper* typeWrapper = static_cast<StructTypeWrapper*>(info.Data().As<External>()->Value());
+  Isolate* isolate = info.GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+  try {
+    StructTypeWrapper* typeWrapper =
+        static_cast<StructTypeWrapper*>(info.Data().As<External>()->Value());
 
-        StructInfo structInfo = typeWrapper->StructInfo();
+    StructInfo structInfo = typeWrapper->StructInfo();
 
-        void* dest = nullptr;
+    void* dest = nullptr;
 
-        if (info.IsConstructCall()) {
-            // A new structure is allocated
-            Local<Value> initializer = info.Length() > 0 ? info[0] : Local<Value>();
-            dest = malloc(structInfo.FFIType()->size);
-            Interop::InitializeStruct(context, dest, structInfo.Fields(), initializer);
-        } else {
-            // The structure is not used as constructor and in this case we assume a pointer is passed to the function
-            // This pointer will be used as backing memory for the structure
-            BaseDataWrapper* wrapper = nullptr;
-            if (info.Length() < 1 || !(wrapper = tns::GetValue(isolate, info[0])) || wrapper->Type() != WrapperType::Pointer) {
-                throw NativeScriptException("A pointer instance must be passed to the structure initializer");
-            }
-
-            PointerWrapper* pw = static_cast<PointerWrapper*>(wrapper);
-            dest = pw->Data();
-        }
-
-        StructWrapper* wrapper = new StructWrapper(structInfo, dest, nullptr);
-        Local<Context> context = isolate->GetCurrentContext();
-        Local<Value> result = ArgConverter::ConvertArgument(context, wrapper);
-
-        std::shared_ptr<Caches> cache = Caches::Get(isolate);
-        std::shared_ptr<Persistent<Value>> poResult = ObjectManager::Register(context, result);
-        std::pair<void*, std::string> key = std::make_pair(wrapper->Data(), structInfo.Name());
-        cache->StructInstances.emplace(key, poResult);
-        tns::DeleteWrapperIfUnused(isolate, result, wrapper);
-
-        info.GetReturnValue().Set(result);
-    } catch (NativeScriptException& ex) {
-        ex.ReThrowToV8(isolate);
+    if (info.IsConstructCall()) {
+      // A new structure is allocated
+      Local<Value> initializer = info.Length() > 0 ? info[0] : Local<Value>();
+      dest = malloc(structInfo.FFIType()->size);
+      Interop::InitializeStruct(context, dest, structInfo.Fields(), initializer);
+    } else {
+      // The structure is not used as constructor and in this case we assume a pointer is passed to
+      // the function This pointer will be used as backing memory for the structure
+      BaseDataWrapper* wrapper = nullptr;
+      if (info.Length() < 1 || !(wrapper = tns::GetValue(isolate, info[0])) ||
+          wrapper->Type() != WrapperType::Pointer) {
+        throw NativeScriptException(
+            "A pointer instance must be passed to the structure initializer");
+      }
+
+      PointerWrapper* pw = static_cast<PointerWrapper*>(wrapper);
+      dest = pw->Data();
     }
-}
 
-void MetadataBuilder::StructEqualsCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
+    StructWrapper* wrapper = new StructWrapper(structInfo, dest, nullptr);
     Local<Context> context = isolate->GetCurrentContext();
-    tns::Assert(info.Length() == 2, isolate);
-
-    Local<Object> arg1 = info[0].As<Object>();
-    Local<Object> arg2 = info[1].As<Object>();
+    Local<Value> result = ArgConverter::ConvertArgument(context, wrapper);
 
-    if (arg1.IsEmpty() || !arg1->IsObject() || arg1->IsNullOrUndefined() ||
-        arg2.IsEmpty() || !arg2->IsObject() || arg2->IsNullOrUndefined()) {
-        info.GetReturnValue().Set(false);
-        return;
-    }
-
-    BaseDataWrapper* wrapper = tns::GetValue(isolate, info.This());
-    if (wrapper == nullptr || wrapper->Type() != WrapperType::StructType) {
-        info.GetReturnValue().Set(false);
-        return;
-    }
-
-    StructTypeWrapper* structTypeWrapper = static_cast<StructTypeWrapper*>(wrapper);
-    StructInfo structInfo = structTypeWrapper->StructInfo();
-
-    std::pair<ffi_type*, void*> pair1 = MetadataBuilder::GetStructData(context, arg1, structInfo);
-    std::pair<ffi_type*, void*> pair2 = MetadataBuilder::GetStructData(context, arg2, structInfo);
-
-    if (pair1.first == nullptr || pair1.second == nullptr ||
-        pair2.first == nullptr || pair2.second == nullptr) {
-        info.GetReturnValue().Set(false);
-        return;
-    }
-
-    ffi_type* ffiType1 = pair1.first;
-    void* arg1Data = pair1.second;
-    void* arg2Data = pair2.second;
-
-    int result = memcmp(arg1Data, arg2Data, ffiType1->size);
-    bool areEqual = result == 0;
-    
-    // these were created by GetStructData
-    if (arg1->InternalFieldCount() < 1) {
-        free(arg1Data);
-    }
-    if (arg2->InternalFieldCount() < 1) {
-        free(arg2Data);
-    }
+    std::shared_ptr<Caches> cache = Caches::Get(isolate);
+    std::shared_ptr<Persistent<Value>> poResult = ObjectManager::Register(context, result);
+    std::pair<void*, std::string> key = std::make_pair(wrapper->Data(), structInfo.Name());
+    cache->StructInstances.emplace(key, poResult);
+    tns::DeleteWrapperIfUnused(isolate, result, wrapper);
 
-    info.GetReturnValue().Set(areEqual);
+    info.GetReturnValue().Set(result);
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+  }
 }
 
-std::pair<ffi_type*, void*> MetadataBuilder::GetStructData(Local<Context> context, Local<Object> initializer, StructInfo structInfo) {
-    ffi_type* ffiType = nullptr;
-    void* data = nullptr;
-
-    if (initializer->InternalFieldCount() < 1) {
-        ffiType = structInfo.FFIType();
-        data = malloc(ffiType->size);
-        Interop::InitializeStruct(context, data, structInfo.Fields(), initializer);
-    } else {
-        Local<External> ext = initializer->GetInternalField(0).As<External>();
-        BaseDataWrapper* wrapper = static_cast<BaseDataWrapper*>(ext->Value());
-        if (wrapper->Type() != WrapperType::Struct) {
-            return std::make_pair(ffiType, data);
-        }
+void MetadataBuilder::StructEqualsCallback(const FunctionCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+  tns::Assert(info.Length() == 2, isolate);
+
+  Local<Object> arg1 = info[0].As<Object>();
+  Local<Object> arg2 = info[1].As<Object>();
+
+  if (arg1.IsEmpty() || !arg1->IsObject() || arg1->IsNullOrUndefined() || arg2.IsEmpty() ||
+      !arg2->IsObject() || arg2->IsNullOrUndefined()) {
+    info.GetReturnValue().Set(false);
+    return;
+  }
+
+  BaseDataWrapper* wrapper = tns::GetValue(isolate, info.This());
+  if (wrapper == nullptr || wrapper->Type() != WrapperType::StructType) {
+    info.GetReturnValue().Set(false);
+    return;
+  }
+
+  StructTypeWrapper* structTypeWrapper = static_cast<StructTypeWrapper*>(wrapper);
+  StructInfo structInfo = structTypeWrapper->StructInfo();
+
+  std::pair<ffi_type*, void*> pair1 = MetadataBuilder::GetStructData(context, arg1, structInfo);
+  std::pair<ffi_type*, void*> pair2 = MetadataBuilder::GetStructData(context, arg2, structInfo);
+
+  if (pair1.first == nullptr || pair1.second == nullptr || pair2.first == nullptr ||
+      pair2.second == nullptr) {
+    info.GetReturnValue().Set(false);
+    return;
+  }
+
+  ffi_type* ffiType1 = pair1.first;
+  void* arg1Data = pair1.second;
+  void* arg2Data = pair2.second;
+
+  int result = memcmp(arg1Data, arg2Data, ffiType1->size);
+  bool areEqual = result == 0;
+
+  // these were created by GetStructData
+  if (arg1->InternalFieldCount() < 1) {
+    free(arg1Data);
+  }
+  if (arg2->InternalFieldCount() < 1) {
+    free(arg2Data);
+  }
+
+  info.GetReturnValue().Set(areEqual);
+}
 
-        StructWrapper* structWrapper = static_cast<StructWrapper*>(wrapper);
-        data = structWrapper->Data();
-        ffiType = structWrapper->StructInfo().FFIType();
+std::pair<ffi_type*, void*> MetadataBuilder::GetStructData(Local<Context> context,
+                                                           Local<Object> initializer,
+                                                           StructInfo structInfo) {
+  ffi_type* ffiType = nullptr;
+  void* data = nullptr;
+
+  if (initializer->InternalFieldCount() < 1) {
+    ffiType = structInfo.FFIType();
+    data = malloc(ffiType->size);
+    Interop::InitializeStruct(context, data, structInfo.Fields(), initializer);
+  } else {
+    Local<External> ext = initializer->GetInternalField(0).As<External>();
+    BaseDataWrapper* wrapper = static_cast<BaseDataWrapper*>(ext->Value());
+    if (wrapper->Type() != WrapperType::Struct) {
+      return std::make_pair(ffiType, data);
     }
 
-    return std::make_pair(ffiType, data);
-}
+    StructWrapper* structWrapper = static_cast<StructWrapper*>(wrapper);
+    data = structWrapper->Data();
+    ffiType = structWrapper->StructInfo().FFIType();
+  }
 
-Local<FunctionTemplate> MetadataBuilder::GetOrCreateConstructorFunctionTemplate(Local<Context> context, const BaseClassMeta* meta, KnownUnknownClassPair pair, const std::vector<std::string>& additionalProtocols) {
-    robin_hood::unordered_map<std::string, uint8_t> instanceMembers;
-    robin_hood::unordered_map<std::string, uint8_t> staticMembers;
-    return MetadataBuilder::GetOrCreateConstructorFunctionTemplateInternal(context, meta, pair, instanceMembers, staticMembers, additionalProtocols);
+  return std::make_pair(ffiType, data);
 }
 
-Local<FunctionTemplate> MetadataBuilder::GetOrCreateConstructorFunctionTemplateInternal(Local<Context> context, const BaseClassMeta* meta, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& instanceMembers, robin_hood::unordered_map<std::string, uint8_t>& staticMembers, const std::vector<std::string>& additionalProtocols) {
-    Isolate* isolate = context->GetIsolate();
-    Local<FunctionTemplate> ctorFuncTemplate;
-    auto cache = Caches::Get(isolate);
+Local<FunctionTemplate> MetadataBuilder::GetOrCreateConstructorFunctionTemplate(
+    Local<Context> context, const BaseClassMeta* meta, KnownUnknownClassPair pair,
+    const std::vector<std::string>& additionalProtocols) {
+  robin_hood::unordered_map<std::string, uint8_t> instanceMembers;
+  robin_hood::unordered_map<std::string, uint8_t> staticMembers;
+  return MetadataBuilder::GetOrCreateConstructorFunctionTemplateInternal(
+      context, meta, pair, instanceMembers, staticMembers, additionalProtocols);
+}
 
-    if (additionalProtocols.empty()) {
-        auto it = cache->CtorFuncTemplates.find(meta);
-        if (it != cache->CtorFuncTemplates.end()) {
-            ctorFuncTemplate = it->second->Get(isolate);
-            return ctorFuncTemplate;
-        }
+Local<FunctionTemplate> MetadataBuilder::GetOrCreateConstructorFunctionTemplateInternal(
+    Local<Context> context, const BaseClassMeta* meta, KnownUnknownClassPair pair,
+    robin_hood::unordered_map<std::string, uint8_t>& instanceMembers,
+    robin_hood::unordered_map<std::string, uint8_t>& staticMembers,
+    const std::vector<std::string>& additionalProtocols) {
+  Isolate* isolate = context->GetIsolate();
+  Local<FunctionTemplate> ctorFuncTemplate;
+  auto cache = Caches::Get(isolate);
+
+  if (additionalProtocols.empty()) {
+    auto it = cache->CtorFuncTemplates.find(meta);
+    if (it != cache->CtorFuncTemplates.end()) {
+      ctorFuncTemplate = it->second->Get(isolate);
+      return ctorFuncTemplate;
     }
-
-    std::string className;
-    CacheItem<BaseClassMeta>* item = new CacheItem<BaseClassMeta>(meta, className);
-    Caches::Get(isolate)->registerCacheBoundObject(item);
-    Local<External> ext = External::New(isolate, item);
-
-    ctorFuncTemplate = FunctionTemplate::New(isolate, ClassConstructorCallback, ext);
-    ctorFuncTemplate->InstanceTemplate()->SetInternalFieldCount(1);
-    ctorFuncTemplate->SetClassName(tns::ToV8String(isolate, meta->name()));
-
-    Local<v8::Function> baseCtorFunc;
-
-    if (meta->type() == MetaType::Interface) {
-        const InterfaceMeta* interfaceMeta = static_cast<const InterfaceMeta*>(meta);
-        const InterfaceMeta* currentMeta = interfaceMeta;
-        while (true) {
-            const char* baseName = currentMeta->baseName();
-            if (baseName != nullptr) {
-                const Meta* baseClassMeta = ArgConverter::GetMeta(baseName);
-                if (baseClassMeta == nullptr || baseClassMeta->type() != MetaType::Interface) {
-                    break;
-                }
-
-                if (!baseClassMeta->isAvailable()) {
-                    // Skip base classes that are not available in the current iOS version
-                    currentMeta = static_cast<const InterfaceMeta*>(baseClassMeta);
-                    continue;
-                }
-
-                const InterfaceMeta* baseMeta = static_cast<const InterfaceMeta*>(baseClassMeta);
-                if (baseMeta != nullptr) {
-                    Local<FunctionTemplate> baseCtorFuncTemplate = MetadataBuilder::GetOrCreateConstructorFunctionTemplateInternal(context, baseMeta, pair, instanceMembers, staticMembers);
-                    ctorFuncTemplate->Inherit(baseCtorFuncTemplate);
-                    auto it = cache->CtorFuncs.find(baseMeta->name());
-                    if (it != cache->CtorFuncs.end()) {
-                        baseCtorFunc = it->second->Get(isolate);
-                    }
-                }
-            }
-            break;
+  }
+
+  std::string className;
+  CacheItem<BaseClassMeta>* item = new CacheItem<BaseClassMeta>(meta, className);
+  Caches::Get(isolate)->registerCacheBoundObject(item);
+  Local<External> ext = External::New(isolate, item);
+
+  ctorFuncTemplate = FunctionTemplate::New(isolate, ClassConstructorCallback, ext);
+  ctorFuncTemplate->InstanceTemplate()->SetInternalFieldCount(1);
+  ctorFuncTemplate->SetClassName(tns::ToV8String(isolate, meta->name()));
+
+  Local<v8::Function> baseCtorFunc;
+
+  if (meta->type() == MetaType::Interface) {
+    const InterfaceMeta* interfaceMeta = static_cast<const InterfaceMeta*>(meta);
+    const InterfaceMeta* currentMeta = interfaceMeta;
+    while (true) {
+      const char* baseName = currentMeta->baseName();
+      if (baseName != nullptr) {
+        const Meta* baseClassMeta = ArgConverter::GetMeta(baseName);
+        if (baseClassMeta == nullptr || baseClassMeta->type() != MetaType::Interface) {
+          break;
         }
-    }
-
-    MetadataBuilder::RegisterInstanceProperties(context, ctorFuncTemplate, meta, meta->name(), pair, instanceMembers);
-    MetadataBuilder::RegisterInstanceMethods(context, ctorFuncTemplate, meta, pair, instanceMembers);
-    MetadataBuilder::RegisterInstanceProtocols(context, ctorFuncTemplate, meta, meta->name(), pair, instanceMembers);
-    MetadataBuilder::RegisterAdditionalProtocols(context, ctorFuncTemplate, pair, additionalProtocols, instanceMembers);
 
-    ctorFuncTemplate->PrototypeTemplate()->Set(tns::ToV8String(isolate, "toString"), FunctionTemplate::New(isolate, MetadataBuilder::ToStringFunctionCallback));
-
-    if (meta->type() == MetaType::Interface) {
-        const InterfaceMeta* interfaceMeta = static_cast<const InterfaceMeta*>(meta);
-        MetadataBuilder::RegisterAllocMethod(isolate, ctorFuncTemplate, interfaceMeta);
-        ctorFuncTemplate->Set(tns::ToV8String(isolate, "extend"), ClassBuilder::GetExtendFunction(isolate, interfaceMeta));
-    }
-
-    NamedPropertyHandlerConfiguration config(nullptr, MetadataBuilder::SwizzledInstanceMethodCallback, nullptr, nullptr, nullptr, MetadataBuilder::SwizzledPropertyCallback, nullptr, ext);
-    ctorFuncTemplate->PrototypeTemplate()->SetHandler(config);
-
-    Local<v8::Function> ctorFunc;
-    bool success = ctorFuncTemplate->GetFunction(context).ToLocal(&ctorFunc);
-    tns::Assert(success, isolate);
-    
-    cache->CtorFuncTemplates.emplace(meta, std::make_unique<Persistent<FunctionTemplate>>(isolate, ctorFuncTemplate));
-
-    if (meta->type() == MetaType::ProtocolType) {
-        const ProtocolMeta* protoMeta = static_cast<const ProtocolMeta*>(meta);
-        tns::SetValue(isolate, ctorFunc, new ObjCProtocolWrapper(objc_getProtocol(meta->name()), protoMeta));
-        cache->ProtocolCtorFuncs.emplace(meta->name(), new Persistent<v8::Function>(isolate, ctorFunc));
-    } else {
-        Class klass = objc_getClass(meta->name());
-        if (klass == nil) {
-            SymbolLoader::instance().ensureModule(meta->topLevelModule());
-            klass = objc_getClass(meta->name());
+        if (!baseClassMeta->isAvailable()) {
+          // Skip base classes that are not available in the current iOS version
+          currentMeta = static_cast<const InterfaceMeta*>(baseClassMeta);
+          continue;
         }
-        tns::SetValue(isolate, ctorFunc, new ObjCClassWrapper(klass));
-        cache->CtorFuncs.emplace(meta->name(), std::make_unique<Persistent<v8::Function>>(isolate, ctorFunc));
-    }
-    ObjectManager::Register(context, ctorFunc);
 
-    Local<Object> global = context->Global();
-    auto jsNameV8String = tns::ToV8String(isolate, meta->jsName());
-    auto maybeSet = global->Set(context, jsNameV8String, ctorFunc);
-    success = maybeSet.FromMaybe(false);
-    tns::Assert(success, isolate);
-
-    if (!baseCtorFunc.IsEmpty()) {
-        bool success;
-        if (!ctorFunc->SetPrototype(context, baseCtorFunc).To(&success) || !success) {
-            tns::Assert(false, isolate);
+        const InterfaceMeta* baseMeta = static_cast<const InterfaceMeta*>(baseClassMeta);
+        if (baseMeta != nullptr) {
+          Local<FunctionTemplate> baseCtorFuncTemplate =
+              MetadataBuilder::GetOrCreateConstructorFunctionTemplateInternal(
+                  context, baseMeta, pair, instanceMembers, staticMembers);
+          ctorFuncTemplate->Inherit(baseCtorFuncTemplate);
+          auto it = cache->CtorFuncs.find(baseMeta->name());
+          if (it != cache->CtorFuncs.end()) {
+            baseCtorFunc = it->second->Get(isolate);
+          }
         }
+      }
+      break;
     }
+  }
+
+  MetadataBuilder::RegisterInstanceProperties(context, ctorFuncTemplate, meta, meta->name(), pair,
+                                              instanceMembers);
+  MetadataBuilder::RegisterInstanceMethods(context, ctorFuncTemplate, meta, pair, instanceMembers);
+  MetadataBuilder::RegisterInstanceProtocols(context, ctorFuncTemplate, meta, meta->name(), pair,
+                                             instanceMembers);
+  MetadataBuilder::RegisterAdditionalProtocols(context, ctorFuncTemplate, pair, additionalProtocols,
+                                               instanceMembers);
+
+  ctorFuncTemplate->PrototypeTemplate()->Set(
+      tns::ToV8String(isolate, "toString"),
+      FunctionTemplate::New(isolate, MetadataBuilder::ToStringFunctionCallback));
+
+  if (meta->type() == MetaType::Interface) {
+    const InterfaceMeta* interfaceMeta = static_cast<const InterfaceMeta*>(meta);
+    MetadataBuilder::RegisterAllocMethod(isolate, ctorFuncTemplate, interfaceMeta);
+    ctorFuncTemplate->Set(tns::ToV8String(isolate, "extend"),
+                          ClassBuilder::GetExtendFunction(isolate, interfaceMeta));
+  }
+
+  NamedPropertyHandlerConfiguration config(nullptr, MetadataBuilder::SwizzledInstanceMethodCallback,
+                                           nullptr, nullptr, nullptr,
+                                           MetadataBuilder::SwizzledPropertyCallback, nullptr, ext);
+  ctorFuncTemplate->PrototypeTemplate()->SetHandler(config);
+
+  Local<v8::Function> ctorFunc;
+  bool success = ctorFuncTemplate->GetFunction(context).ToLocal(&ctorFunc);
+  tns::Assert(success, isolate);
+
+  cache->CtorFuncTemplates.emplace(
+      meta, std::make_unique<Persistent<FunctionTemplate>>(isolate, ctorFuncTemplate));
+
+  if (meta->type() == MetaType::ProtocolType) {
+    const ProtocolMeta* protoMeta = static_cast<const ProtocolMeta*>(meta);
+    tns::SetValue(isolate, ctorFunc,
+                  new ObjCProtocolWrapper(objc_getProtocol(meta->name()), protoMeta));
+    cache->ProtocolCtorFuncs.emplace(meta->name(), new Persistent<v8::Function>(isolate, ctorFunc));
+  } else {
+    Class klass = objc_getClass(meta->name());
+    if (klass == nil) {
+      SymbolLoader::instance().ensureModule(meta->topLevelModule());
+      klass = objc_getClass(meta->name());
+    }
+    tns::SetValue(isolate, ctorFunc, new ObjCClassWrapper(klass));
+    cache->CtorFuncs.emplace(meta->name(),
+                             std::make_unique<Persistent<v8::Function>>(isolate, ctorFunc));
+  }
+  ObjectManager::Register(context, ctorFunc);
+
+  Local<Object> global = context->Global();
+  auto jsNameV8String = tns::ToV8String(isolate, meta->jsName());
+  auto maybeSet = global->Set(context, jsNameV8String, ctorFunc);
+  success = maybeSet.FromMaybe(false);
+  tns::Assert(success, isolate);
+
+  if (!baseCtorFunc.IsEmpty()) {
+    bool success;
+    if (!ctorFunc->SetPrototype(context, baseCtorFunc).To(&success) || !success) {
+      tns::Assert(false, isolate);
+    }
+  }
 
-    MetadataBuilder::RegisterStaticMethods(context, ctorFunc, meta, pair, staticMembers);
-    MetadataBuilder::RegisterStaticProperties(context, ctorFunc, meta, meta->name(), pair, staticMembers);
-    MetadataBuilder::RegisterStaticProtocols(context, ctorFunc, meta, meta->name(), pair, staticMembers);
+  MetadataBuilder::RegisterStaticMethods(context, ctorFunc, meta, pair, staticMembers);
+  MetadataBuilder::RegisterStaticProperties(context, ctorFunc, meta, meta->name(), pair,
+                                            staticMembers);
+  MetadataBuilder::RegisterStaticProtocols(context, ctorFunc, meta, meta->name(), pair,
+                                           staticMembers);
 
-    Local<Value> prototypeValue;
-    success = ctorFunc->Get(context, tns::ToV8String(isolate, "prototype")).ToLocal(&prototypeValue);
-    tns::Assert(success, isolate);
-    Local<Object> prototype = prototypeValue.As<Object>();
+  Local<Value> prototypeValue;
+  success = ctorFunc->Get(context, tns::ToV8String(isolate, "prototype")).ToLocal(&prototypeValue);
+  tns::Assert(success, isolate);
+  Local<Object> prototype = prototypeValue.As<Object>();
 
-    Persistent<Value>* poPrototype = new Persistent<Value>(isolate, prototype);
-    cache->Prototypes.emplace(meta, poPrototype);
+  Persistent<Value>* poPrototype = new Persistent<Value>(isolate, prototype);
+  cache->Prototypes.emplace(meta, poPrototype);
 
-    return ctorFuncTemplate;
+  return ctorFuncTemplate;
 }
 
 void MetadataBuilder::ToStringFunctionCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    Local<Object> thiz = info.This();
-    BaseDataWrapper* wrapper = tns::GetValue(isolate, thiz);
-
-    if (wrapper == nullptr || wrapper->Type() != WrapperType::ObjCObject) {
-        info.GetReturnValue().Set(thiz);
-        return;
-    }
-
-    ObjCDataWrapper* dataWrapper = static_cast<ObjCDataWrapper*>(wrapper);
-    id target = dataWrapper->Data();
-    if (target == nil) {
-        info.GetReturnValue().Set(thiz);
-        return;
-    }
-
-    std::string description = [[target description] UTF8String];
-    Local<v8::String> returnValue = tns::ToV8String(info.GetIsolate(), description);
-    info.GetReturnValue().Set(returnValue);
+  Isolate* isolate = info.GetIsolate();
+  Local<Object> thiz = info.This();
+  BaseDataWrapper* wrapper = tns::GetValue(isolate, thiz);
+
+  if (wrapper == nullptr || wrapper->Type() != WrapperType::ObjCObject) {
+    info.GetReturnValue().Set(thiz);
+    return;
+  }
+
+  ObjCDataWrapper* dataWrapper = static_cast<ObjCDataWrapper*>(wrapper);
+  id target = dataWrapper->Data();
+  if (target == nil) {
+    info.GetReturnValue().Set(thiz);
+    return;
+  }
+
+  std::string description = [[target description] UTF8String];
+  Local<v8::String> returnValue = tns::ToV8String(info.GetIsolate(), description);
+  info.GetReturnValue().Set(returnValue);
 }
 
-void MetadataBuilder::RegisterAllocMethod(Isolate* isolate, Local<FunctionTemplate> ctorFuncTemplate, const InterfaceMeta* interfaceMeta) {
-    std::string className;
-    CacheItem<InterfaceMeta>* item = new CacheItem<InterfaceMeta>(interfaceMeta, className);
-    Caches::Get(isolate)->registerCacheBoundObject(item);
-    Local<External> ext = External::New(isolate, item);
-    Local<FunctionTemplate> allocFuncTemplate = FunctionTemplate::New(isolate, AllocCallback, ext);
-    ctorFuncTemplate->Set(tns::ToV8String(isolate, "alloc"), allocFuncTemplate);
+void MetadataBuilder::RegisterAllocMethod(Isolate* isolate,
+                                          Local<FunctionTemplate> ctorFuncTemplate,
+                                          const InterfaceMeta* interfaceMeta) {
+  std::string className;
+  CacheItem<InterfaceMeta>* item = new CacheItem<InterfaceMeta>(interfaceMeta, className);
+  Caches::Get(isolate)->registerCacheBoundObject(item);
+  Local<External> ext = External::New(isolate, item);
+  Local<FunctionTemplate> allocFuncTemplate = FunctionTemplate::New(isolate, AllocCallback, ext);
+  ctorFuncTemplate->Set(tns::ToV8String(isolate, "alloc"), allocFuncTemplate);
 }
 
-void MetadataBuilder::RegisterInstanceMethods(Local<Context> context, Local<FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names) {
-    Isolate* isolate = context->GetIsolate();
-    Local<ObjectTemplate> proto = ctorFuncTemplate->PrototypeTemplate();
-
-    for (auto it = meta->instanceMethods->begin(); it != meta->instanceMethods->end(); it++) {
-        const MethodMeta* methodMeta = (*it).valuePtr();
-        if (!methodMeta->isAvailableInClasses(pair, false)) {
-            continue;
-        }
+void MetadataBuilder::RegisterInstanceMethods(
+    Local<Context> context, Local<FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta,
+    KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names) {
+  Isolate* isolate = context->GetIsolate();
+  Local<ObjectTemplate> proto = ctorFuncTemplate->PrototypeTemplate();
 
-        std::string methodName = methodMeta->name();
-        auto methodsIt = names.find(methodName);
-        if (methodsIt == names.end()) {
-            CacheItem<MethodMeta>* item = new CacheItem<MethodMeta>(methodMeta, meta->name());
-            Caches::Get(isolate)->registerCacheBoundObject(item);
-            Local<External> ext = External::New(isolate, item);
-            Local<FunctionTemplate> instanceMethodTemplate = FunctionTemplate::New(isolate, MethodCallback, ext);
-            proto->Set(tns::ToV8String(isolate, methodMeta->jsName()), instanceMethodTemplate);
-            names.emplace(methodName, 0);
-        }
+  for (auto it = meta->instanceMethods->begin(); it != meta->instanceMethods->end(); it++) {
+    const MethodMeta* methodMeta = (*it).valuePtr();
+    if (!methodMeta->isAvailableInClasses(pair, false)) {
+      continue;
     }
-}
-
-void MetadataBuilder::RegisterInstanceProperties(Local<Context> context, Local<FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta, const std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names) {
-    Isolate* isolate = context->GetIsolate();
-    Local<ObjectTemplate> proto = ctorFuncTemplate->PrototypeTemplate();
-
-    for (auto it = meta->instanceProps->begin(); it != meta->instanceProps->end(); it++) {
-        const PropertyMeta* propMeta = (*it).valuePtr();
-        if (!propMeta->isAvailableInClasses(pair, false)) {
-            continue;
-        }
-
-        uint8_t accessors = 0;
-        if (propMeta->hasGetter()) {
-            accessors++;
-        }
-        if (propMeta->hasSetter()) {
-            accessors++;
-        }
 
-        std::string propertyName = propMeta->name();
-        auto propertiesIt = names.find(propertyName);
-        if (accessors > 0 && (propertiesIt == names.end() || propertiesIt->second < accessors)) {
-            CacheItem<PropertyMeta>* item = new CacheItem<PropertyMeta>(propMeta, className);
-            Caches::Get(isolate)->registerCacheBoundObject(item);
-            Local<External> ext = External::New(isolate, item);
-            Local<FunctionTemplate> getter = FunctionTemplate::New(isolate, PropertyGetterCallback, ext);
-            Local<FunctionTemplate> setter = FunctionTemplate::New(isolate, PropertySetterCallback, ext);
-            proto->SetAccessorProperty(tns::ToV8String(isolate, propMeta->jsName()), getter, setter, PropertyAttribute::None, AccessControl::DEFAULT);
-            names.emplace(propertyName, accessors);
-        }
+    std::string methodName = methodMeta->name();
+    auto methodsIt = names.find(methodName);
+    if (methodsIt == names.end()) {
+      CacheItem<MethodMeta>* item = new CacheItem<MethodMeta>(methodMeta, meta->name());
+      Caches::Get(isolate)->registerCacheBoundObject(item);
+      Local<External> ext = External::New(isolate, item);
+      Local<FunctionTemplate> instanceMethodTemplate =
+          FunctionTemplate::New(isolate, MethodCallback, ext);
+      proto->Set(tns::ToV8String(isolate, methodMeta->jsName()), instanceMethodTemplate);
+      names.emplace(methodName, 0);
     }
+  }
 }
 
-void MetadataBuilder::RegisterInstanceProtocols(Local<Context> context, Local<FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta, const std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names) {
-    if (meta->type() == MetaType::ProtocolType) {
-        MetadataBuilder::RegisterInstanceMethods(context, ctorFuncTemplate, meta, pair, names);
-        MetadataBuilder::RegisterInstanceProperties(context, ctorFuncTemplate, meta, className, pair, names);
+void MetadataBuilder::RegisterInstanceProperties(
+    Local<Context> context, Local<FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta,
+    const std::string className, KnownUnknownClassPair pair,
+    robin_hood::unordered_map<std::string, uint8_t>& names) {
+  Isolate* isolate = context->GetIsolate();
+  Local<ObjectTemplate> proto = ctorFuncTemplate->PrototypeTemplate();
+
+  for (auto it = meta->instanceProps->begin(); it != meta->instanceProps->end(); it++) {
+    const PropertyMeta* propMeta = (*it).valuePtr();
+    if (!propMeta->isAvailableInClasses(pair, false)) {
+      continue;
     }
 
-    for (auto itProto = meta->protocols->begin(); itProto != meta->protocols->end(); itProto++) {
-        std::string protocolName = (*itProto).valuePtr();
-        const Meta* m = ArgConverter::GetMeta(protocolName.c_str());
-        if (m != nullptr) {
-            const BaseClassMeta* protoMeta = static_cast<const BaseClassMeta*>(m);
-            MetadataBuilder::RegisterInstanceProtocols(context, ctorFuncTemplate, protoMeta, className, pair, names);
-        }
+    uint8_t accessors = 0;
+    if (propMeta->hasGetter()) {
+      accessors++;
     }
-}
-
-void MetadataBuilder::RegisterAdditionalProtocols(Local<Context> context, Local<FunctionTemplate> ctorFuncTemplate, KnownUnknownClassPair pair, const std::vector<std::string>& additionalProtocols, robin_hood::unordered_map<std::string, uint8_t>& names) {
-    for (std::string protocolName : additionalProtocols) {
-        const Meta* meta = ArgConverter::GetMeta(protocolName.c_str());
-        if (meta != nullptr) {
-            const BaseClassMeta* baseMeta = static_cast<const BaseClassMeta*>(meta);
-            MetadataBuilder::RegisterInstanceMethods(context, ctorFuncTemplate, baseMeta, pair, names);
-            MetadataBuilder::RegisterInstanceProperties(context, ctorFuncTemplate, baseMeta, baseMeta->name(), pair, names);
-
-            std::vector<std::string> metaProtocols;
-            for (auto it = baseMeta->protocols->begin(); it != baseMeta->protocols->end(); it++) {
-                std::string name = (*it).valuePtr();
-                metaProtocols.push_back(name);
-            }
-
-            MetadataBuilder::RegisterAdditionalProtocols(context, ctorFuncTemplate, pair, metaProtocols, names);
-        }
+    if (propMeta->hasSetter()) {
+      accessors++;
     }
-}
 
-void MetadataBuilder::RegisterStaticMethods(Local<Context> context, Local<v8::Function> ctorFunc, const BaseClassMeta* meta, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names) {
-    Isolate* isolate = context->GetIsolate();
-    for (auto it = meta->staticMethods->begin(); it != meta->staticMethods->end(); it++) {
-        const MethodMeta* methodMeta = (*it).valuePtr();
-        if (!methodMeta->isAvailableInClasses(pair, true)) {
-            continue;
-        }
-
-        std::string methodName = methodMeta->name();
-        auto methodsIt = names.find(methodName);
-        if (methodsIt == names.end()) {
-            CacheItem<MethodMeta>* item = new CacheItem<MethodMeta>(methodMeta, meta->name());
-            Caches::Get(isolate)->registerCacheBoundObject(item);
-            Local<External> ext = External::New(isolate, item);
-            Local<FunctionTemplate> staticMethodTemplate = FunctionTemplate::New(isolate, MethodCallback, ext);
-            Local<v8::Function> staticMethod;
-            if (!staticMethodTemplate->GetFunction(context).ToLocal(&staticMethod)) {
-                tns::Assert(false, isolate);
-            }
-
-            DefineFunctionLengthProperty(context, methodMeta->encodings(), staticMethod);
-
-            if (!ctorFunc->Has(context, tns::ToV8String(isolate, methodMeta->jsName())).FromJust()) {
-                bool success = ctorFunc->Set(context, tns::ToV8String(isolate, methodMeta->jsName()), staticMethod).FromMaybe(false);
-                tns::Assert(success, isolate);
-            }
-
-            names.emplace(methodName, 0);
-            
-        }
+    std::string propertyName = propMeta->name();
+    auto propertiesIt = names.find(propertyName);
+    if (accessors > 0 && (propertiesIt == names.end() || propertiesIt->second < accessors)) {
+      CacheItem<PropertyMeta>* item = new CacheItem<PropertyMeta>(propMeta, className);
+      Caches::Get(isolate)->registerCacheBoundObject(item);
+      Local<External> ext = External::New(isolate, item);
+      Local<FunctionTemplate> getter = FunctionTemplate::New(isolate, PropertyGetterCallback, ext);
+      Local<FunctionTemplate> setter = FunctionTemplate::New(isolate, PropertySetterCallback, ext);
+      proto->SetAccessorProperty(tns::ToV8String(isolate, propMeta->jsName()), getter, setter,
+                                 PropertyAttribute::None, AccessControl::DEFAULT);
+      names.emplace(propertyName, accessors);
     }
+  }
 }
 
-void MetadataBuilder::RegisterStaticProperties(Local<Context> context, Local<v8::Function> ctorFunc, const BaseClassMeta* meta, const std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names) {
-    Isolate* isolate = context->GetIsolate();
-
-    for (auto it = meta->staticProps->begin(); it != meta->staticProps->end(); it++) {
-        const PropertyMeta* propMeta = (*it).valuePtr();
-        if (!propMeta->isAvailableInClasses(pair, true)) {
-            continue;
-        }
-
-        uint8_t accessors = 0;
-        if (propMeta->hasGetter()) {
-            accessors++;
-        }
-
-        if (propMeta->hasSetter()) {
-            accessors++;
-        }
-
-        std::string propertyName = propMeta->name();
-        auto propertiesIt = names.find(propertyName);
-        if (accessors > 0 && (propertiesIt == names.end() || propertiesIt->second < accessors)) {
-            CacheItem<PropertyMeta>* item = new CacheItem<PropertyMeta>(propMeta, className);
-            Caches::Get(isolate)->registerCacheBoundObject(item);
-            Local<External> ext = External::New(isolate, item);
-
-            Local<v8::String> propName = tns::ToV8String(isolate, propMeta->jsName());
-            bool success;
-            Maybe<bool> maybeSuccess = ctorFunc->SetAccessor(context, propName, PropertyNameGetterCallback, PropertyNameSetterCallback, ext, AccessControl::DEFAULT, PropertyAttribute::DontDelete);
-            if (!maybeSuccess.To(&success) || !success) {
-                tns::Assert(false, isolate);
-            }
-            names.emplace(propertyName, accessors);
-        }
+void MetadataBuilder::RegisterInstanceProtocols(
+    Local<Context> context, Local<FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta,
+    const std::string className, KnownUnknownClassPair pair,
+    robin_hood::unordered_map<std::string, uint8_t>& names) {
+  if (meta->type() == MetaType::ProtocolType) {
+    MetadataBuilder::RegisterInstanceMethods(context, ctorFuncTemplate, meta, pair, names);
+    MetadataBuilder::RegisterInstanceProperties(context, ctorFuncTemplate, meta, className, pair,
+                                                names);
+  }
+
+  for (auto itProto = meta->protocols->begin(); itProto != meta->protocols->end(); itProto++) {
+    std::string protocolName = (*itProto).valuePtr();
+    const Meta* m = ArgConverter::GetMeta(protocolName.c_str());
+    if (m != nullptr) {
+      const BaseClassMeta* protoMeta = static_cast<const BaseClassMeta*>(m);
+      MetadataBuilder::RegisterInstanceProtocols(context, ctorFuncTemplate, protoMeta, className,
+                                                 pair, names);
     }
+  }
 }
 
-void MetadataBuilder::RegisterStaticProtocols(Local<Context> context, Local<v8::Function> ctorFunc, const BaseClassMeta* meta, const std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names) {
-    if (meta->type() == MetaType::ProtocolType) {
-        MetadataBuilder::RegisterStaticMethods(context, ctorFunc, meta, pair, names);
-        MetadataBuilder::RegisterStaticProperties(context, ctorFunc, meta, className, pair, names);
-    }
-
-    const GlobalTable<GlobalTableType::ByJsName>* globalTable = MetaFile::instance()->globalTableJs();
-    for (auto itProto = meta->protocols->begin(); itProto != meta->protocols->end(); itProto++) {
-        std::string protocolName = (*itProto).valuePtr();
-        const ProtocolMeta* protoMeta = globalTable->findProtocol(protocolName.c_str());
-        if (protoMeta != nullptr) {
-            MetadataBuilder::RegisterStaticProtocols(context, ctorFunc, protoMeta, className, pair, names);
-        }
+void MetadataBuilder::RegisterAdditionalProtocols(
+    Local<Context> context, Local<FunctionTemplate> ctorFuncTemplate, KnownUnknownClassPair pair,
+    const std::vector<std::string>& additionalProtocols,
+    robin_hood::unordered_map<std::string, uint8_t>& names) {
+  for (std::string protocolName : additionalProtocols) {
+    const Meta* meta = ArgConverter::GetMeta(protocolName.c_str());
+    if (meta != nullptr) {
+      const BaseClassMeta* baseMeta = static_cast<const BaseClassMeta*>(meta);
+      MetadataBuilder::RegisterInstanceMethods(context, ctorFuncTemplate, baseMeta, pair, names);
+      MetadataBuilder::RegisterInstanceProperties(context, ctorFuncTemplate, baseMeta,
+                                                  baseMeta->name(), pair, names);
+
+      std::vector<std::string> metaProtocols;
+      for (auto it = baseMeta->protocols->begin(); it != baseMeta->protocols->end(); it++) {
+        std::string name = (*it).valuePtr();
+        metaProtocols.push_back(name);
+      }
+
+      MetadataBuilder::RegisterAdditionalProtocols(context, ctorFuncTemplate, pair, metaProtocols,
+                                                   names);
     }
+  }
 }
 
-void MetadataBuilder::ClassConstructorCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    Local<Context> context = isolate->GetCurrentContext();
-    tns::Assert(info.IsConstructCall(), isolate);
-    try {
-        CacheItem<BaseClassMeta>* item = static_cast<CacheItem<BaseClassMeta>*>(info.Data().As<External>()->Value());
-        Class klass = objc_getClass(item->meta_->name());
-
-        const InterfaceMeta* interfaceMeta = static_cast<const InterfaceMeta*>(item->meta_);
-        ArgConverter::ConstructObject(context, info, klass, interfaceMeta);
-    } catch (NativeScriptException& ex) {
-        ex.ReThrowToV8(isolate);
+void MetadataBuilder::RegisterStaticMethods(
+    Local<Context> context, Local<v8::Function> ctorFunc, const BaseClassMeta* meta,
+    KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names) {
+  Isolate* isolate = context->GetIsolate();
+  for (auto it = meta->staticMethods->begin(); it != meta->staticMethods->end(); it++) {
+    const MethodMeta* methodMeta = (*it).valuePtr();
+    if (!methodMeta->isAvailableInClasses(pair, true)) {
+      continue;
     }
-}
 
-void MetadataBuilder::AllocCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    tns::Assert(info.Length() == 0, isolate);
-
-    try {
-        Local<Object> thiz = info.This();
-        Class klass;
-
-        BaseDataWrapper* wrapper = tns::GetValue(isolate, thiz);
-        if (wrapper != nullptr && wrapper->Type() == WrapperType::ObjCClass) {
-            ObjCClassWrapper* classWrapper = static_cast<ObjCClassWrapper*>(wrapper);
-            klass = classWrapper->Klass();
-        } else {
-            CacheItem<InterfaceMeta>* item = static_cast<CacheItem<InterfaceMeta>*>(info.Data().As<External>()->Value());
-            const InterfaceMeta* meta = item->meta_;
-            klass = objc_getClass(meta->name());
-        }
+    std::string methodName = methodMeta->name();
+    auto methodsIt = names.find(methodName);
+    if (methodsIt == names.end()) {
+      CacheItem<MethodMeta>* item = new CacheItem<MethodMeta>(methodMeta, meta->name());
+      Caches::Get(isolate)->registerCacheBoundObject(item);
+      Local<External> ext = External::New(isolate, item);
+      Local<FunctionTemplate> staticMethodTemplate =
+          FunctionTemplate::New(isolate, MethodCallback, ext);
+      Local<v8::Function> staticMethod;
+      if (!staticMethodTemplate->GetFunction(context).ToLocal(&staticMethod)) {
+        tns::Assert(false, isolate);
+      }
+
+      DefineFunctionLengthProperty(context, methodMeta->encodings(), staticMethod);
+
+      if (!ctorFunc->Has(context, tns::ToV8String(isolate, methodMeta->jsName())).FromJust()) {
+        bool success =
+            ctorFunc->Set(context, tns::ToV8String(isolate, methodMeta->jsName()), staticMethod)
+                .FromMaybe(false);
+        tns::Assert(success, isolate);
+      }
 
-        Local<Context> context = isolate->GetCurrentContext();
-        ObjCAllocDataWrapper* allocWrapper = new ObjCAllocDataWrapper(klass);
-        Local<Value> result = ArgConverter::CreateJsWrapper(context, allocWrapper, Local<Object>());
-        info.GetReturnValue().Set(result);
-    } catch (NativeScriptException& ex) {
-        ex.ReThrowToV8(isolate);
+      names.emplace(methodName, 0);
     }
+  }
 }
 
-void MetadataBuilder::MethodCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    CacheItem<MethodMeta>* item = static_cast<CacheItem<MethodMeta>*>(info.Data().As<External>()->Value());
-
-    bool instanceMethod = info.This()->InternalFieldCount() > 0;
-    V8FunctionCallbackArgs args(info);
-
-    std::string className = item->className_;
-
-    Local<Object> thiz = info.This();
-    if (thiz->IsFunction()) {
-        if (BaseDataWrapper* wrapper = tns::GetValue(isolate, thiz)) {
-            ObjCClassWrapper* classWrapper = static_cast<ObjCClassWrapper*>(wrapper);
-            className = class_getName(classWrapper->Klass());
-        }
-    }
-
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Value> result = instanceMethod
-        ? MetadataBuilder::InvokeMethod(context, item->meta_, info.This(), args, className, true)
-        : MetadataBuilder::InvokeMethod(context, item->meta_, Local<Object>(), args, className, true);
+void MetadataBuilder::RegisterStaticProperties(
+    Local<Context> context, Local<v8::Function> ctorFunc, const BaseClassMeta* meta,
+    const std::string className, KnownUnknownClassPair pair,
+    robin_hood::unordered_map<std::string, uint8_t>& names) {
+  Isolate* isolate = context->GetIsolate();
 
-    if (!result.IsEmpty()) {
-        info.GetReturnValue().Set(result);
+  for (auto it = meta->staticProps->begin(); it != meta->staticProps->end(); it++) {
+    const PropertyMeta* propMeta = (*it).valuePtr();
+    if (!propMeta->isAvailableInClasses(pair, true)) {
+      continue;
     }
-}
 
-void MetadataBuilder::PropertyGetterCallback(const FunctionCallbackInfo<Value> &info) {
-    Local<Object> receiver = info.This();
-
-    if (receiver->InternalFieldCount() < 1) {
-        return;
+    uint8_t accessors = 0;
+    if (propMeta->hasGetter()) {
+      accessors++;
     }
 
-    Isolate* isolate = info.GetIsolate();
-    CacheItem<PropertyMeta>* item = static_cast<CacheItem<PropertyMeta>*>(info.Data().As<External>()->Value());
-    if (!item->meta_->hasGetter()) {
-        Local<Value> error = Exception::Error(tns::ToV8String(isolate, "Property is not readable."));
-        isolate->ThrowException(error);
-        return;
+    if (propMeta->hasSetter()) {
+      accessors++;
     }
 
-    V8EmptyValueArgs args;
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Value> result = MetadataBuilder::InvokeMethod(context, item->meta_->getter(), receiver, args, item->className_, true);
-    if (!result.IsEmpty()) {
-        info.GetReturnValue().Set(result);
+    std::string propertyName = propMeta->name();
+    auto propertiesIt = names.find(propertyName);
+    if (accessors > 0 && (propertiesIt == names.end() || propertiesIt->second < accessors)) {
+      CacheItem<PropertyMeta>* item = new CacheItem<PropertyMeta>(propMeta, className);
+      Caches::Get(isolate)->registerCacheBoundObject(item);
+      Local<External> ext = External::New(isolate, item);
+
+      Local<v8::String> propName = tns::ToV8String(isolate, propMeta->jsName());
+      bool success;
+      Maybe<bool> maybeSuccess = ctorFunc->SetAccessor(
+          context, propName, PropertyNameGetterCallback, PropertyNameSetterCallback, ext,
+          AccessControl::DEFAULT, PropertyAttribute::DontDelete);
+      if (!maybeSuccess.To(&success) || !success) {
+        tns::Assert(false, isolate);
+      }
+      names.emplace(propertyName, accessors);
     }
+  }
 }
 
-void MetadataBuilder::PropertySetterCallback(const FunctionCallbackInfo<Value> &info) {
-    Isolate* isolate = info.GetIsolate();
-    CacheItem<PropertyMeta>* item = static_cast<CacheItem<PropertyMeta>*>(info.Data().As<External>()->Value());
-    if (!item->meta_->hasSetter()) {
-        Local<Value> error = Exception::Error(tns::ToV8String(isolate, "Attempted to assign to readonly property."));
-        isolate->ThrowException(error);
-        return;
+void MetadataBuilder::RegisterStaticProtocols(
+    Local<Context> context, Local<v8::Function> ctorFunc, const BaseClassMeta* meta,
+    const std::string className, KnownUnknownClassPair pair,
+    robin_hood::unordered_map<std::string, uint8_t>& names) {
+  if (meta->type() == MetaType::ProtocolType) {
+    MetadataBuilder::RegisterStaticMethods(context, ctorFunc, meta, pair, names);
+    MetadataBuilder::RegisterStaticProperties(context, ctorFunc, meta, className, pair, names);
+  }
+
+  const GlobalTable<GlobalTableType::ByJsName>* globalTable = MetaFile::instance()->globalTableJs();
+  for (auto itProto = meta->protocols->begin(); itProto != meta->protocols->end(); itProto++) {
+    std::string protocolName = (*itProto).valuePtr();
+    const ProtocolMeta* protoMeta = globalTable->findProtocol(protocolName.c_str());
+    if (protoMeta != nullptr) {
+      MetadataBuilder::RegisterStaticProtocols(context, ctorFunc, protoMeta, className, pair,
+                                               names);
     }
+  }
+}
 
-    Local<Object> receiver = info.This();
-    Local<Value> value = info[0];
-    V8SimpleValueArgs args(value);
-    Local<Context> context = isolate->GetCurrentContext();
-    MetadataBuilder::InvokeMethod(context, item->meta_->setter(), receiver, args, item->className_, true);
+void MetadataBuilder::ClassConstructorCallback(const FunctionCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+  tns::Assert(info.IsConstructCall(), isolate);
+  try {
+    CacheItem<BaseClassMeta>* item =
+        static_cast<CacheItem<BaseClassMeta>*>(info.Data().As<External>()->Value());
+    Class klass = objc_getClass(item->meta_->name());
+
+    const InterfaceMeta* interfaceMeta = static_cast<const InterfaceMeta*>(item->meta_);
+    ArgConverter::ConstructObject(context, info, klass, interfaceMeta);
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+  }
 }
 
-void MetadataBuilder::PropertyNameGetterCallback(Local<v8::Name> name, const PropertyCallbackInfo<Value> &info) {
-    Isolate* isolate = info.GetIsolate();
-    CacheItem<PropertyMeta>* item = static_cast<CacheItem<PropertyMeta>*>(info.Data().As<External>()->Value());
-    if (!item->meta_->hasGetter()) {
-        Local<Value> error = Exception::Error(tns::ToV8String(isolate, "Property is not readable."));
-        isolate->ThrowException(error);
-        return;
-    }
+void MetadataBuilder::AllocCallback(const FunctionCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  tns::Assert(info.Length() == 0, isolate);
 
-    V8EmptyValueArgs args;
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Value> result = MetadataBuilder::InvokeMethod(context, item->meta_->getter(), Local<Object>(), args, item->className_, false);
-    if (!result.IsEmpty()) {
-        info.GetReturnValue().Set(result);
-    }
-}
+  try {
+    Local<Object> thiz = info.This();
+    Class klass;
 
-void MetadataBuilder::PropertyNameSetterCallback(Local<v8::Name> name, Local<Value> value, const PropertyCallbackInfo<void> &info) {
-    Isolate* isolate = info.GetIsolate();
-    CacheItem<PropertyMeta>* item = static_cast<CacheItem<PropertyMeta>*>(info.Data().As<External>()->Value());
-    if (!item->meta_->hasSetter()) {
-        Local<Value> error = Exception::Error(tns::ToV8String(isolate, "Attempted to assign to readonly property."));
-        isolate->ThrowException(error);
-        return;
+    BaseDataWrapper* wrapper = tns::GetValue(isolate, thiz);
+    if (wrapper != nullptr && wrapper->Type() == WrapperType::ObjCClass) {
+      ObjCClassWrapper* classWrapper = static_cast<ObjCClassWrapper*>(wrapper);
+      klass = classWrapper->Klass();
+    } else {
+      CacheItem<InterfaceMeta>* item =
+          static_cast<CacheItem<InterfaceMeta>*>(info.Data().As<External>()->Value());
+      const InterfaceMeta* meta = item->meta_;
+      klass = objc_getClass(meta->name());
     }
 
-    V8SimpleValueArgs args(value);
     Local<Context> context = isolate->GetCurrentContext();
-    MetadataBuilder::InvokeMethod(context, item->meta_->setter(), Local<Object>(), args, item->className_, false);
+    ObjCAllocDataWrapper* allocWrapper = new ObjCAllocDataWrapper(klass);
+    Local<Value> result = ArgConverter::CreateJsWrapper(context, allocWrapper, Local<Object>());
+    info.GetReturnValue().Set(result);
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+  }
 }
 
-void MetadataBuilder::StructPropertyGetterCallback(Local<v8::Name> property, const PropertyCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    Local<Object> thiz = info.This();
+void MetadataBuilder::MethodCallback(const FunctionCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  CacheItem<MethodMeta>* item =
+      static_cast<CacheItem<MethodMeta>*>(info.Data().As<External>()->Value());
+
+  bool instanceMethod = info.This()->InternalFieldCount() > 0;
+  V8FunctionCallbackArgs args(info);
 
-    std::string propertyName = tns::ToString(isolate, property);
+  std::string className = item->className_;
 
-    if (propertyName == "") {
-        info.GetReturnValue().Set(thiz);
-        return;
+  Local<Object> thiz = info.This();
+  if (thiz->IsFunction()) {
+    if (BaseDataWrapper* wrapper = tns::GetValue(isolate, thiz)) {
+      ObjCClassWrapper* classWrapper = static_cast<ObjCClassWrapper*>(wrapper);
+      className = class_getName(classWrapper->Klass());
     }
+  }
 
-    BaseDataWrapper* baseWrapper = tns::GetValue(isolate, thiz);
-    tns::Assert(baseWrapper != nullptr && baseWrapper->Type() == WrapperType::Struct, isolate);
-    StructWrapper* wrapper = static_cast<StructWrapper*>(baseWrapper);
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Value> result =
+      instanceMethod
+          ? MetadataBuilder::InvokeMethod(context, item->meta_, info.This(), args, className, true)
+          : MetadataBuilder::InvokeMethod(context, item->meta_, Local<Object>(), args, className,
+                                          true);
 
-    StructInfo structInfo = wrapper->StructInfo();
+  if (!result.IsEmpty()) {
+    info.GetReturnValue().Set(result);
+  }
+}
 
-    std::shared_ptr<Caches> cache = Caches::Get(isolate);
-    std::pair<void*, std::string> key = std::make_pair(wrapper->Data(), structInfo.Name());
-    std::shared_ptr<Persistent<Value>> parentStruct = nullptr;
-    auto x = cache->StructInstances.find(key);
-    if (x != cache->StructInstances.end()) {
-        parentStruct = x->second;
-    }
+void MetadataBuilder::PropertyGetterCallback(const FunctionCallbackInfo<Value>& info) {
+  Local<Object> receiver = info.This();
+
+  if (receiver->InternalFieldCount() < 1) {
+    return;
+  }
+
+  Isolate* isolate = info.GetIsolate();
+  CacheItem<PropertyMeta>* item =
+      static_cast<CacheItem<PropertyMeta>*>(info.Data().As<External>()->Value());
+  if (!item->meta_->hasGetter()) {
+    Local<Value> error = Exception::Error(tns::ToV8String(isolate, "Property is not readable."));
+    isolate->ThrowException(error);
+    return;
+  }
+
+  V8EmptyValueArgs args;
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Value> result = MetadataBuilder::InvokeMethod(context, item->meta_->getter(), receiver,
+                                                      args, item->className_, true);
+  if (!result.IsEmpty()) {
+    info.GetReturnValue().Set(result);
+  }
+}
 
-    std::vector<StructField> fields = structInfo.Fields();
-    auto it = std::find_if(fields.begin(), fields.end(), [&propertyName](StructField &f) { return f.Name() == propertyName; });
-    if (it == fields.end()) {
-        info.GetReturnValue().SetUndefined();
-        return;
-    }
+void MetadataBuilder::PropertySetterCallback(const FunctionCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  CacheItem<PropertyMeta>* item =
+      static_cast<CacheItem<PropertyMeta>*>(info.Data().As<External>()->Value());
+  if (!item->meta_->hasSetter()) {
+    Local<Value> error =
+        Exception::Error(tns::ToV8String(isolate, "Attempted to assign to readonly property."));
+    isolate->ThrowException(error);
+    return;
+  }
+
+  Local<Object> receiver = info.This();
+  Local<Value> value = info[0];
+  V8SimpleValueArgs args(value);
+  Local<Context> context = isolate->GetCurrentContext();
+  MetadataBuilder::InvokeMethod(context, item->meta_->setter(), receiver, args, item->className_,
+                                true);
+}
 
-    StructField field = *it;
-    const TypeEncoding* fieldEncoding = field.Encoding();
-    ptrdiff_t offset = field.Offset();
-    void* buffer = wrapper->Data();
-    BaseCall call((uint8_t*)buffer, offset);
+void MetadataBuilder::PropertyNameGetterCallback(Local<v8::Name> name,
+                                                 const PropertyCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  CacheItem<PropertyMeta>* item =
+      static_cast<CacheItem<PropertyMeta>*>(info.Data().As<External>()->Value());
+  if (!item->meta_->hasGetter()) {
+    Local<Value> error = Exception::Error(tns::ToV8String(isolate, "Property is not readable."));
+    isolate->ThrowException(error);
+    return;
+  }
+
+  V8EmptyValueArgs args;
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Value> result = MetadataBuilder::InvokeMethod(
+      context, item->meta_->getter(), Local<Object>(), args, item->className_, false);
+  if (!result.IsEmpty()) {
+    info.GetReturnValue().Set(result);
+  }
+}
 
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Value> result = Interop::GetResult(context, fieldEncoding, &call, false, parentStruct, true);
+void MetadataBuilder::PropertyNameSetterCallback(Local<v8::Name> name, Local<Value> value,
+                                                 const PropertyCallbackInfo<void>& info) {
+  Isolate* isolate = info.GetIsolate();
+  CacheItem<PropertyMeta>* item =
+      static_cast<CacheItem<PropertyMeta>*>(info.Data().As<External>()->Value());
+  if (!item->meta_->hasSetter()) {
+    Local<Value> error =
+        Exception::Error(tns::ToV8String(isolate, "Attempted to assign to readonly property."));
+    isolate->ThrowException(error);
+    return;
+  }
+
+  V8SimpleValueArgs args(value);
+  Local<Context> context = isolate->GetCurrentContext();
+  MetadataBuilder::InvokeMethod(context, item->meta_->setter(), Local<Object>(), args,
+                                item->className_, false);
+}
 
-    info.GetReturnValue().Set(result);
+void MetadataBuilder::StructPropertyGetterCallback(Local<v8::Name> property,
+                                                   const PropertyCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  Local<Object> thiz = info.This();
+
+  std::string propertyName = tns::ToString(isolate, property);
+
+  if (propertyName == "") {
+    info.GetReturnValue().Set(thiz);
+    return;
+  }
+
+  BaseDataWrapper* baseWrapper = tns::GetValue(isolate, thiz);
+  tns::Assert(baseWrapper != nullptr && baseWrapper->Type() == WrapperType::Struct, isolate);
+  StructWrapper* wrapper = static_cast<StructWrapper*>(baseWrapper);
+
+  StructInfo structInfo = wrapper->StructInfo();
+
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  std::pair<void*, std::string> key = std::make_pair(wrapper->Data(), structInfo.Name());
+  std::shared_ptr<Persistent<Value>> parentStruct = nullptr;
+  auto x = cache->StructInstances.find(key);
+  if (x != cache->StructInstances.end()) {
+    parentStruct = x->second;
+  }
+
+  std::vector<StructField> fields = structInfo.Fields();
+  auto it = std::find_if(fields.begin(), fields.end(),
+                         [&propertyName](StructField& f) { return f.Name() == propertyName; });
+  if (it == fields.end()) {
+    info.GetReturnValue().SetUndefined();
+    return;
+  }
+
+  StructField field = *it;
+  const TypeEncoding* fieldEncoding = field.Encoding();
+  ptrdiff_t offset = field.Offset();
+  void* buffer = wrapper->Data();
+  BaseCall call((uint8_t*)buffer, offset);
+
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Value> result =
+      Interop::GetResult(context, fieldEncoding, &call, false, parentStruct, true);
+
+  info.GetReturnValue().Set(result);
 }
 
-void MetadataBuilder::StructPropertySetterCallback(Local<v8::Name> property, Local<Value> value, const PropertyCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Object> thiz = info.This();
+void MetadataBuilder::StructPropertySetterCallback(Local<v8::Name> property, Local<Value> value,
+                                                   const PropertyCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Object> thiz = info.This();
 
-    std::string propertyName = tns::ToString(isolate, property);
+  std::string propertyName = tns::ToString(isolate, property);
 
-    if (propertyName == "") {
-        info.GetReturnValue().Set(thiz);
-        return;
-    }
+  if (propertyName == "") {
+    info.GetReturnValue().Set(thiz);
+    return;
+  }
 
-    Local<External> ext = thiz->GetInternalField(0).As<External>();
-    StructWrapper* wrapper = static_cast<StructWrapper*>(ext->Value());
+  Local<External> ext = thiz->GetInternalField(0).As<External>();
+  StructWrapper* wrapper = static_cast<StructWrapper*>(ext->Value());
 
-    StructInfo structInfo = wrapper->StructInfo();
-    std::vector<StructField> fields = structInfo.Fields();
+  StructInfo structInfo = wrapper->StructInfo();
+  std::vector<StructField> fields = structInfo.Fields();
 
-    auto it = std::find_if(fields.begin(), fields.end(), [&propertyName](StructField &f) { return f.Name() == propertyName; });
-    if (it == fields.end()) {
-        return;
-    }
+  auto it = std::find_if(fields.begin(), fields.end(),
+                         [&propertyName](StructField& f) { return f.Name() == propertyName; });
+  if (it == fields.end()) {
+    return;
+  }
 
-    StructField field = *it;
-    Interop::SetStructPropertyValue(context, wrapper, field, value);
+  StructField field = *it;
+  Interop::SetStructPropertyValue(context, wrapper, field, value);
 }
 
-void MetadataBuilder::DefineFunctionLengthProperty(Local<Context> context, const TypeEncodingsList<ArrayCount>* encodings, Local<v8::Function> func) {
-    Isolate* isolate = context->GetIsolate();
-    const PropertyAttribute readOnlyFlags = static_cast<PropertyAttribute>(PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
-    int paramsCount = std::max(0, encodings->count - 1);
-    bool success = func->DefineOwnProperty(context, tns::ToV8String(isolate, "length"), Number::New(isolate, paramsCount), readOnlyFlags).FromMaybe(false);
-    tns::Assert(success, isolate);
+void MetadataBuilder::DefineFunctionLengthProperty(Local<Context> context,
+                                                   const TypeEncodingsList<ArrayCount>* encodings,
+                                                   Local<v8::Function> func) {
+  Isolate* isolate = context->GetIsolate();
+  const PropertyAttribute readOnlyFlags = static_cast<PropertyAttribute>(
+      PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+  int paramsCount = std::max(0, encodings->count - 1);
+  bool success = func->DefineOwnProperty(context, tns::ToV8String(isolate, "length"),
+                                         Number::New(isolate, paramsCount), readOnlyFlags)
+                     .FromMaybe(false);
+  tns::Assert(success, isolate);
 }
 
-Local<Value> MetadataBuilder::InvokeMethod(Local<Context> context, const MethodMeta* meta, Local<Object> receiver, V8Args& args, std::string containingClass, bool isMethodCallback) {
-    Class klass = objc_getClass(containingClass.c_str());
-    // TODO: Find out if the isMethodCallback property can be determined based on a UITableViewController.prototype.viewDidLoad.call(this) or super.viewDidLoad() call
-
-    #ifdef DEBUG
-        id value = Runtime::GetAppConfigValue("logRuntimeDetail");
-        bool logRuntimeDetail = value ? [value boolValue] : false;
-        if (logRuntimeDetail) {
-            // NOTE: stringWithFormat is slow, perhaps use different c string concatenation?
-            NSString* message = [NSString stringWithFormat:@"MetadataBuilder::InvokeMethod: class {%s}, selector {%s}, isInitializer {%s}, type {%s}, lib {%s}",
-                                containingClass.c_str(),
-                                meta->selectorAsString(),
-                                meta->isInitializer() ? "true":"false",
-                                meta->typeName(),
-                                meta->topLevelModule()->getName()];
-            Log(@"%@", message);
-        }
-    #endif
-    
-    try {
-        return ArgConverter::Invoke(context, klass, receiver, args, meta, isMethodCallback);
-    } catch (NativeScriptException& ex) {
-        Isolate* isolate = context->GetIsolate();
-        ex.ReThrowToV8(isolate);
-        return Local<Value>();
-    }
+Local<Value> MetadataBuilder::InvokeMethod(Local<Context> context, const MethodMeta* meta,
+                                           Local<Object> receiver, V8Args& args,
+                                           std::string containingClass, bool isMethodCallback) {
+  Class klass = objc_getClass(containingClass.c_str());
+  // TODO: Find out if the isMethodCallback property can be determined based on a
+  // UITableViewController.prototype.viewDidLoad.call(this) or super.viewDidLoad() call
+
+#ifdef DEBUG
+  id value = Runtime::GetAppConfigValue("logRuntimeDetail");
+  bool logRuntimeDetail = value ? [value boolValue] : false;
+  if (logRuntimeDetail) {
+    // NOTE: stringWithFormat is slow, perhaps use different c string concatenation?
+    NSString* message =
+        [NSString stringWithFormat:@"MetadataBuilder::InvokeMethod: class {%s}, selector {%s}, "
+                                   @"isInitializer {%s}, type {%s}, lib {%s}",
+                                   containingClass.c_str(), meta->selectorAsString(),
+                                   meta->isInitializer() ? "true" : "false", meta->typeName(),
+                                   meta->topLevelModule()->getName()];
+    Log(@"%@", message);
+  }
+#endif
+
+  try {
+    return ArgConverter::Invoke(context, klass, receiver, args, meta, isMethodCallback);
+  } catch (NativeScriptException& ex) {
+    Isolate* isolate = context->GetIsolate();
+    ex.ReThrowToV8(isolate);
+    return Local<Value>();
+  }
 }
 
 void MetadataBuilder::CFunctionCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    try {
-        CacheItem<FunctionMeta>* item = static_cast<CacheItem<FunctionMeta>*>(info.Data().As<External>()->Value());
-
-        if (strcmp(item->meta_->jsName(), "UIApplicationMain") == 0) {
-            std::vector<std::shared_ptr<Persistent<Value>>> args;
-            for (int i = 0; i < info.Length(); i++) {
-                args.push_back(std::make_shared<Persistent<Value>>(isolate, info[i]));
-            }
-
-            Tasks::Register([isolate, item, args]() {
-                v8::Locker locker(isolate);
-                Isolate::Scope isolate_scope(isolate);
-                HandleScope handle_scope(isolate);
-                std::vector<Local<Value>> localArgs;
-                localArgs.reserve(args.size());
-                for (int i = 0; i < args.size(); i++) {
-                    Local<Value> arg = args[i]->Get(isolate);
-                    localArgs.push_back(arg);
-                }
-                const TypeEncoding* typeEncoding = item->meta_->encodings()->first();
-                V8VectorArgs vectorArgs(localArgs);
-                Local<Context> context = Caches::Get(isolate)->GetContext();
-                v8::Unlocker unlocker(isolate);
-                CMethodCall methodCall(context, item->userData_, typeEncoding, vectorArgs, item->meta_->ownsReturnedCocoaObject(), false);
-                Interop::CallFunction(methodCall);
-            });
-
-            return;
+  Isolate* isolate = info.GetIsolate();
+  try {
+    CacheItem<FunctionMeta>* item =
+        static_cast<CacheItem<FunctionMeta>*>(info.Data().As<External>()->Value());
+
+    if (strcmp(item->meta_->jsName(), "UIApplicationMain") == 0) {
+      std::vector<std::shared_ptr<Persistent<Value>>> args;
+      for (int i = 0; i < info.Length(); i++) {
+        args.push_back(std::make_shared<Persistent<Value>>(isolate, info[i]));
+      }
+
+      Tasks::Register([isolate, item, args]() {
+        v8::Locker locker(isolate);
+        Isolate::Scope isolate_scope(isolate);
+        HandleScope handle_scope(isolate);
+        std::vector<Local<Value>> localArgs;
+        localArgs.reserve(args.size());
+        for (int i = 0; i < args.size(); i++) {
+          Local<Value> arg = args[i]->Get(isolate);
+          localArgs.push_back(arg);
         }
-
-        V8FunctionCallbackArgs args(info);
         const TypeEncoding* typeEncoding = item->meta_->encodings()->first();
-        Local<Context> context = isolate->GetCurrentContext();
-        const FunctionMeta* funcMeta = item->meta_;
-        CMethodCall methodCall(context, item->userData_, typeEncoding, args, funcMeta->ownsReturnedCocoaObject(), funcMeta->returnsUnmanaged());
-        Local<Value> result = Interop::CallFunction(methodCall);
-
-        if (typeEncoding->type != BinaryTypeEncodingType::VoidEncoding) {
-            info.GetReturnValue().Set(result);
-        }
-    } catch (NativeScriptException& ex) {
-        ex.ReThrowToV8(isolate);
+        V8VectorArgs vectorArgs(localArgs);
+        Local<Context> context = Caches::Get(isolate)->GetContext();
+        v8::Unlocker unlocker(isolate);
+        CMethodCall methodCall(context, item->userData_, typeEncoding, vectorArgs,
+                               item->meta_->ownsReturnedCocoaObject(), false);
+        Interop::CallFunction(methodCall);
+      });
+
+      return;
     }
-}
-
-void MetadataBuilder::SwizzledInstanceMethodCallback(Local<v8::Name> property, Local<Value> value, const PropertyCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    std::string methodName = tns::ToString(isolate, property);
-
-    CacheItem<BaseClassMeta>* item = static_cast<CacheItem<BaseClassMeta>*>(info.Data().As<External>()->Value());
-    const BaseClassMeta* meta = item->meta_;
-
-    Class klass = objc_getClass(meta->name());
-    if (klass == nil) {
-        return;
-    }
-
-    int index = meta->instanceMethods->binarySearch([methodName](const PtrTo<MethodMeta>& current) {
-        const MethodMeta* methodMeta = current.valuePtr();
-        return strcmp(methodMeta->jsName(), methodName.c_str());
-    });
 
-    if (index < 0) {
-        return;
-    }
+    V8FunctionCallbackArgs args(info);
+    const TypeEncoding* typeEncoding = item->meta_->encodings()->first();
+    Local<Context> context = isolate->GetCurrentContext();
+    const FunctionMeta* funcMeta = item->meta_;
+    CMethodCall methodCall(context, item->userData_, typeEncoding, args,
+                           funcMeta->ownsReturnedCocoaObject(), funcMeta->returnsUnmanaged());
+    Local<Value> result = Interop::CallFunction(methodCall);
 
-    const MethodMeta* methodMeta = meta->instanceMethods->operator[](index).valuePtr();
-
-    const TypeEncoding* typeEncoding = methodMeta->encodings()->first();
-    int argsCount = methodMeta->encodings()->count - 1;
-    std::string compilerEncoding = ClassBuilder::GetTypeEncoding(typeEncoding, argsCount);
-    std::shared_ptr<Persistent<Value>> poCallback = std::make_shared<Persistent<Value>>(isolate, value);
-    MethodCallbackWrapper* userData = new MethodCallbackWrapper(isolate, poCallback, 2, argsCount, typeEncoding);
-    IMP methodBody = Interop::CreateMethod(2, argsCount, typeEncoding, ArgConverter::MethodCallback, userData);
-    IMP nativeImp = class_replaceMethod(klass, methodMeta->selector(), methodBody, compilerEncoding.c_str());
-    if (nativeImp) {
-        std::string selector = methodMeta->selectorAsString();
-        SEL nativeSelector = sel_registerName((Constants::SwizzledPrefix + selector).c_str());
-        class_addMethod(klass, nativeSelector, nativeImp, compilerEncoding.c_str());
+    if (typeEncoding->type != BinaryTypeEncodingType::VoidEncoding) {
+      info.GetReturnValue().Set(result);
     }
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+  }
 }
 
-void MetadataBuilder::SwizzledPropertyCallback(Local<v8::Name> property, const PropertyDescriptor& desc, const PropertyCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    std::string propertyName = tns::ToString(isolate, property);
-
-    CacheItem<BaseClassMeta>* item = static_cast<CacheItem<BaseClassMeta>*>(info.Data().As<External>()->Value());
-    const BaseClassMeta* meta = item->meta_;
-
-    Class klass = objc_getClass(meta->name());
-    if (klass == nil) {
-        return;
-    }
-
-    int index = meta->instanceProps->binarySearch([propertyName](const PtrTo<PropertyMeta>& current) {
-        const PropertyMeta* propertyMeta = current.valuePtr();
-        return strcmp(propertyMeta->jsName(), propertyName.c_str());
-    });
-
-    if (index < 0) {
-        return;
-    }
+void MetadataBuilder::SwizzledInstanceMethodCallback(Local<v8::Name> property, Local<Value> value,
+                                                     const PropertyCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  std::string methodName = tns::ToString(isolate, property);
+
+  CacheItem<BaseClassMeta>* item =
+      static_cast<CacheItem<BaseClassMeta>*>(info.Data().As<External>()->Value());
+  const BaseClassMeta* meta = item->meta_;
+
+  Class klass = objc_getClass(meta->name());
+  if (klass == nil) {
+    return;
+  }
+
+  int index = meta->instanceMethods->binarySearch([methodName](const PtrTo<MethodMeta>& current) {
+    const MethodMeta* methodMeta = current.valuePtr();
+    return strcmp(methodMeta->jsName(), methodName.c_str());
+  });
+
+  if (index < 0) {
+    return;
+  }
+
+  const MethodMeta* methodMeta = meta->instanceMethods->operator[](index).valuePtr();
+
+  const TypeEncoding* typeEncoding = methodMeta->encodings()->first();
+  int argsCount = methodMeta->encodings()->count - 1;
+  std::string compilerEncoding = ClassBuilder::GetTypeEncoding(typeEncoding, argsCount);
+  std::shared_ptr<Persistent<Value>> poCallback =
+      std::make_shared<Persistent<Value>>(isolate, value);
+  MethodCallbackWrapper* userData =
+      new MethodCallbackWrapper(isolate, poCallback, 2, argsCount, typeEncoding);
+  IMP methodBody =
+      Interop::CreateMethod(2, argsCount, typeEncoding, ArgConverter::MethodCallback, userData);
+  IMP nativeImp =
+      class_replaceMethod(klass, methodMeta->selector(), methodBody, compilerEncoding.c_str());
+  if (nativeImp) {
+    std::string selector = methodMeta->selectorAsString();
+    SEL nativeSelector = sel_registerName((Constants::SwizzledPrefix + selector).c_str());
+    class_addMethod(klass, nativeSelector, nativeImp, compilerEncoding.c_str());
+  }
+}
 
-    const PropertyMeta* propertyMeta = meta->instanceProps->operator[](index).valuePtr();
-
-    if (desc.has_get()) {
-        FFIMethodCallback getterCallback = [](ffi_cif* cif, void* retValue, void** argValues, void* userData) {
-            PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
-            v8::Locker locker(context->isolate_);
-            Isolate::Scope isolate_scope(context->isolate_);
-            HandleScope handle_scope(context->isolate_);
-            Local<v8::Function> getterFunc = context->callback_->Get(context->isolate_);
-            Local<Value> res;
-
-            id thiz = *static_cast<const id*>(argValues[0]);
-            auto cache = Caches::Get(context->isolate_);
-            auto it = cache->Instances.find(thiz);
-
-            Local<Context> v8Context = Caches::Get(context->isolate_)->GetContext();
-            ObjCDataWrapper* wrapper = nullptr;
-            Local<Object> self_ = it != cache->Instances.end()
-                ? it->second->Get(context->isolate_).As<Object>()
-                : ArgConverter::CreateJsWrapper(v8Context, wrapper = new ObjCDataWrapper(thiz), Local<Object>()).As<Object>();
-            if (wrapper != nullptr) {
-                tns::DeleteWrapperIfUnused(context->isolate_, self_, wrapper);
-            }
-            tns::Assert(getterFunc->Call(v8Context, self_, 0, nullptr).ToLocal(&res), context->isolate_);
-
-            const TypeEncoding* typeEncoding = context->meta_->getter()->encodings()->first();
-            ArgConverter::SetValue(v8Context, retValue, res, typeEncoding);
-        };
-
-        const char* compilerEncoding = "@@:";
-        const TypeEncoding* typeEncoding = propertyMeta->getter()->encodings()->first();
-
-        Local<Value> getter = desc.get();
-        std::shared_ptr<Persistent<v8::Function>> poGetterFunc = std::make_shared<Persistent<v8::Function>>(isolate, getter.As<v8::Function>());
-        PropertyCallbackContext* userData = new PropertyCallbackContext(isolate, poGetterFunc, nullptr, propertyMeta);
-        IMP impGetter = Interop::CreateMethod(2, 0, typeEncoding, getterCallback, userData);
-        IMP nativeImp = class_replaceMethod(klass, propertyMeta->getter()->selector(), impGetter, compilerEncoding);
-        std::string selector = propertyMeta->getter()->selectorAsString();
-        SEL nativeSelector = sel_registerName((Constants::SwizzledPrefix + selector).c_str());
-        class_addMethod(klass, nativeSelector, nativeImp, compilerEncoding);
-    }
+void MetadataBuilder::SwizzledPropertyCallback(Local<v8::Name> property,
+                                               const PropertyDescriptor& desc,
+                                               const PropertyCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  std::string propertyName = tns::ToString(isolate, property);
+
+  CacheItem<BaseClassMeta>* item =
+      static_cast<CacheItem<BaseClassMeta>*>(info.Data().As<External>()->Value());
+  const BaseClassMeta* meta = item->meta_;
+
+  Class klass = objc_getClass(meta->name());
+  if (klass == nil) {
+    return;
+  }
+
+  int index = meta->instanceProps->binarySearch([propertyName](const PtrTo<PropertyMeta>& current) {
+    const PropertyMeta* propertyMeta = current.valuePtr();
+    return strcmp(propertyMeta->jsName(), propertyName.c_str());
+  });
+
+  if (index < 0) {
+    return;
+  }
+
+  const PropertyMeta* propertyMeta = meta->instanceProps->operator[](index).valuePtr();
+
+  if (desc.has_get()) {
+    FFIMethodCallback getterCallback = [](ffi_cif* cif, void* retValue, void** argValues,
+                                          void* userData) {
+      PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
+      Isolate* isolate = context->isolate_;
+      // Scopes-before-@throw: capture a branded escape and @throw only after
+      // the inner block's V8 scopes destruct.
+      NSException* __strong pendingThrow = nil;
+      {
+        v8::Locker locker(isolate);
+        Isolate::Scope isolate_scope(isolate);
+        HandleScope handle_scope(isolate);
+        Local<v8::Function> getterFunc = context->callback_->Get(isolate);
+        Local<Value> res;
+
+        id thiz = *static_cast<const id*>(argValues[0]);
+        auto cache = Caches::Get(isolate);
+        auto it = cache->Instances.find(thiz);
+
+        Local<Context> v8Context = Caches::Get(isolate)->GetContext();
+        ObjCDataWrapper* wrapper = nullptr;
+        Local<Object> self_ =
+            it != cache->Instances.end()
+                ? it->second->Get(isolate).As<Object>()
+                : ArgConverter::CreateJsWrapper(v8Context, wrapper = new ObjCDataWrapper(thiz),
+                                                Local<Object>())
+                      .As<Object>();
+        if (wrapper != nullptr) {
+          tns::DeleteWrapperIfUnused(isolate, self_, wrapper);
+        }
+        TryCatch tc(isolate);
+        if (!getterFunc->Call(v8Context, self_, 0, nullptr).ToLocal(&res)) {
+          NSException* ex = ArgConverter::HandleBoundaryException(v8Context, tc);
+          if (ex != nil) {
+            pendingThrow = ex;
+          }
+          memset(retValue, 0, cif->rtype->size);
+        } else {
+          const TypeEncoding* typeEncoding = context->meta_->getter()->encodings()->first();
+          ArgConverter::SetValue(v8Context, retValue, res, typeEncoding);
+        }
+      }
+      if (pendingThrow != nil) {
+        @throw pendingThrow;
+      }
+    };
+
+    const char* compilerEncoding = "@@:";
+    const TypeEncoding* typeEncoding = propertyMeta->getter()->encodings()->first();
+
+    Local<Value> getter = desc.get();
+    std::shared_ptr<Persistent<v8::Function>> poGetterFunc =
+        std::make_shared<Persistent<v8::Function>>(isolate, getter.As<v8::Function>());
+    PropertyCallbackContext* userData =
+        new PropertyCallbackContext(isolate, poGetterFunc, nullptr, propertyMeta);
+    IMP impGetter = Interop::CreateMethod(2, 0, typeEncoding, getterCallback, userData);
+    IMP nativeImp =
+        class_replaceMethod(klass, propertyMeta->getter()->selector(), impGetter, compilerEncoding);
+    std::string selector = propertyMeta->getter()->selectorAsString();
+    SEL nativeSelector = sel_registerName((Constants::SwizzledPrefix + selector).c_str());
+    class_addMethod(klass, nativeSelector, nativeImp, compilerEncoding);
+  }
+
+  if (desc.has_set()) {
+    FFIMethodCallback setterCallback = [](ffi_cif* cif, void* retValue, void** argValues,
+                                          void* userData) {
+      PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
+      Isolate* isolate = context->isolate_;
+      NSException* __strong pendingThrow = nil;
+      {
+        v8::Locker locker(isolate);
+        Isolate::Scope isolate_scope(isolate);
+        HandleScope handle_scope(isolate);
+        Local<v8::Function> setterFunc = context->callback_->Get(isolate);
+        Local<Value> res;
+
+        Local<Context> v8Context = Caches::Get(isolate)->GetContext();
+
+        id thiz = *static_cast<const id*>(argValues[0]);
+        auto cache = Caches::Get(isolate);
+        auto it = cache->Instances.find(thiz);
+        ObjCDataWrapper* wrapper = nullptr;
+        Local<Object> self_ =
+            it != cache->Instances.end()
+                ? it->second->Get(isolate).As<Object>()
+                : ArgConverter::CreateJsWrapper(v8Context, wrapper = new ObjCDataWrapper(thiz),
+                                                Local<Object>())
+                      .As<Object>();
+        if (wrapper != nullptr) {
+          tns::DeleteWrapperIfUnused(isolate, self_, wrapper);
+        }
 
-    if (desc.has_set()) {
-        FFIMethodCallback setterCallback = [](ffi_cif* cif, void* retValue, void** argValues, void* userData) {
-            PropertyCallbackContext* context = static_cast<PropertyCallbackContext*>(userData);
-            v8::Locker locker(context->isolate_);
-            Isolate::Scope isolate_scope(context->isolate_);
-            HandleScope handle_scope(context->isolate_);
-            Local<v8::Function> setterFunc = context->callback_->Get(context->isolate_);
-            Local<Value> res;
-
-            Local<Context> v8Context = Caches::Get(context->isolate_)->GetContext();
-
-            id thiz = *static_cast<const id*>(argValues[0]);
-            auto cache = Caches::Get(context->isolate_);
-            auto it = cache->Instances.find(thiz);
-            Local<Object> self_ = it != cache->Instances.end()
-                ? it->second->Get(context->isolate_).As<Object>()
-                : ArgConverter::CreateJsWrapper(v8Context, new ObjCDataWrapper(thiz), Local<Object>()).As<Object>();
-
-            uint8_t* argBuffer = (uint8_t*)argValues[2];
-            const TypeEncoding* typeEncoding = context->meta_->setter()->encodings()->first()->next();
-            BaseCall call(argBuffer);
-            Local<Value> jsWrapper = Interop::GetResult(v8Context, typeEncoding, &call, true);
-            Local<Value> params[1] = { jsWrapper };
-
-            tns::Assert(setterFunc->Call(context->isolate_->GetCurrentContext(), self_, 1, params).ToLocal(&res), context->isolate_);
-        };
-
-        const TypeEncoding* typeEncoding = propertyMeta->setter()->encodings()->first();
-        Local<Value> setter = desc.set();
-        std::shared_ptr<Persistent<v8::Function>> poSetterFunc = std::make_shared<Persistent<v8::Function>>(isolate, setter.As<v8::Function>());
-        PropertyCallbackContext* userData = new PropertyCallbackContext(isolate, poSetterFunc, nullptr, propertyMeta);
-        IMP impSetter = Interop::CreateMethod(2, 1, typeEncoding, setterCallback, userData);
-
-        const char* compilerEncoding = "v@:@";
-        IMP nativeImp = class_replaceMethod(klass, propertyMeta->setter()->selector(), impSetter, compilerEncoding);
-        std::string selector = propertyMeta->setter()->selectorAsString();
-        SEL nativeSelector = sel_registerName((Constants::SwizzledPrefix + selector).c_str());
-        class_addMethod(klass, nativeSelector, nativeImp, compilerEncoding);
-    }
+        uint8_t* argBuffer = (uint8_t*)argValues[2];
+        const TypeEncoding* typeEncoding = context->meta_->setter()->encodings()->first()->next();
+        BaseCall call(argBuffer);
+        Local<Value> jsWrapper = Interop::GetResult(v8Context, typeEncoding, &call, true);
+        Local<Value> params[1] = {jsWrapper};
+
+        TryCatch tc(isolate);
+        if (!setterFunc->Call(v8Context, self_, 1, params).ToLocal(&res)) {
+          NSException* ex = ArgConverter::HandleBoundaryException(v8Context, tc);
+          if (ex != nil) {
+            pendingThrow = ex;
+          }
+          // Setter returns void; nothing to write on a JS throw.
+        }
+      }
+      if (pendingThrow != nil) {
+        @throw pendingThrow;
+      }
+    };
+
+    const TypeEncoding* typeEncoding = propertyMeta->setter()->encodings()->first();
+    Local<Value> setter = desc.set();
+    std::shared_ptr<Persistent<v8::Function>> poSetterFunc =
+        std::make_shared<Persistent<v8::Function>>(isolate, setter.As<v8::Function>());
+    PropertyCallbackContext* userData =
+        new PropertyCallbackContext(isolate, poSetterFunc, nullptr, propertyMeta);
+    IMP impSetter = Interop::CreateMethod(2, 1, typeEncoding, setterCallback, userData);
+
+    const char* compilerEncoding = "v@:@";
+    IMP nativeImp =
+        class_replaceMethod(klass, propertyMeta->setter()->selector(), impSetter, compilerEncoding);
+    std::string selector = propertyMeta->setter()->selectorAsString();
+    SEL nativeSelector = sel_registerName((Constants::SwizzledPrefix + selector).c_str());
+    class_addMethod(klass, nativeSelector, nativeImp, compilerEncoding);
+  }
 }
 
-}
+}  // namespace tns
diff --git a/NativeScript/runtime/ModuleInternal.mm b/NativeScript/runtime/ModuleInternal.mm
index 6a8697ff..475f4ce4 100644
--- a/NativeScript/runtime/ModuleInternal.mm
+++ b/NativeScript/runtime/ModuleInternal.mm
@@ -5,6 +5,7 @@
 #include <unistd.h>
 #include <utime.h>
 #include <string>
+#include "BuiltinLoader.h"
 #include "Caches.h"
 #include "DevFlags.h"
 #include "Helpers.h"
@@ -90,32 +91,14 @@ bool IsESModule(const std::string& path) {
 }
 
 ModuleInternal::ModuleInternal(Local<Context> context) {
-  std::string requireFactoryScript = "(function() { "
-                                     "    function require_factory(requireInternal, dirName) { "
-                                     "        return function require(modulePath) { "
-                                     "            if(global.__pauseOnNextRequire) {  debugger; "
-                                     "global.__pauseOnNextRequire = false; }"
-                                     "            return requireInternal(modulePath, dirName); "
-                                     "        } "
-                                     "    } "
-                                     "    return require_factory; "
-                                     "})()";
-
   Isolate* isolate = context->GetIsolate();
   Local<Object> global = context->Global();
-  Local<Script> script;
   TryCatch tc(isolate);
-  if (!Script::Compile(context, tns::ToV8String(isolate, requireFactoryScript.c_str()))
-           .ToLocal(&script) &&
-      tc.HasCaught()) {
-    tns::LogError(isolate, tc);
-    Log(@"FATAL: Failed to compile require factory script");
-    return;
-  }
-
   Local<Value> result;
-  if (!script->Run(context).ToLocal(&result) && tc.HasCaught()) {
-    tns::LogError(isolate, tc);
+  if (!BuiltinLoader::RunBuiltin(context, BuiltinId::kRequireFactory).ToLocal(&result)) {
+    if (tc.HasCaught()) {
+      tns::LogError(isolate, tc);
+    }
     Log(@"FATAL: Failed to run require factory script");
     return;
   }
@@ -1186,36 +1169,30 @@ throw NativeScriptException(
   // Create a module object with exports that throws when accessed
   Local<Object> moduleObj = Object::New(isolate);
 
-  // Create a Proxy that throws an error when any property is accessed
+  // Build a Proxy that throws when any property is accessed. The factory
+  // (internal/placeholder-module.js) is compiled once per isolate and invoked
+  // with the per-module error message.
   std::string errorMessage =
       "Module '" + moduleName + "' is not available. This is an optional module.";
-  std::string proxyCode = "(function() {"
-                          "  const error = new Error('" +
-                          errorMessage +
-                          "');"
-                          "  return new Proxy({}, {"
-                          "    get: function(target, prop) {"
-                          "      throw error;"
-                          "    },"
-                          "    set: function(target, prop, value) {"
-                          "      throw error;"
-                          "    },"
-                          "    has: function(target, prop) {"
-                          "      return false;"
-                          "    },"
-                          "    ownKeys: function(target) {"
-                          "      return [];"
-                          "    },"
-                          "    getPrototypeOf: function(target) {"
-                          "      return null;"
-                          "    }"
-                          "  });"
-                          "})()";
-
-  Local<Script> proxyScript;
-  if (Script::Compile(context, tns::ToV8String(isolate, proxyCode.c_str())).ToLocal(&proxyScript)) {
+
+  auto cache = Caches::Get(isolate);
+  Local<v8::Function> factory;
+  if (cache->PlaceholderModuleFactoryFunc != nullptr) {
+    factory = cache->PlaceholderModuleFactoryFunc->Get(isolate);
+  } else {
+    Local<Value> factoryValue;
+    if (BuiltinLoader::RunBuiltin(context, BuiltinId::kPlaceholderModule).ToLocal(&factoryValue) &&
+        factoryValue->IsFunction()) {
+      factory = factoryValue.As<v8::Function>();
+      cache->PlaceholderModuleFactoryFunc =
+          std::make_unique<Persistent<v8::Function>>(isolate, factory);
+    }
+  }
+
+  if (!factory.IsEmpty()) {
+    Local<Value> args[] = {tns::ToV8String(isolate, errorMessage)};
     Local<Value> proxyObject;
-    if (proxyScript->Run(context).ToLocal(&proxyObject)) {
+    if (factory->Call(context, v8::Undefined(isolate), 1, args).ToLocal(&proxyObject)) {
       // Set the exports to the proxy object
       bool success = moduleObj->Set(context, tns::ToV8String(isolate, "exports"), proxyObject)
                          .FromMaybe(false);
@@ -1244,6 +1221,13 @@ throw NativeScriptException(
   // Cache the placeholder module
   this->loadedModules_[cacheKey] = std::make_shared<Persistent<Object>>(isolate, moduleObj);
 
+  // The first require() of a missing optional module throws (node semantics,
+  // relied on by the shared require tests); the placeholder above only serves
+  // repeat requires through the module cache. This matches the historical
+  // behavior, where the placeholder-proxy compile left a pending exception.
+  isolate->ThrowException(
+      Exception::Error(tns::ToV8String(isolate, "Cannot find module '" + moduleName + "'")));
+
   return moduleObj;
 }
 
diff --git a/NativeScript/runtime/NSExceptionSupport.h b/NativeScript/runtime/NSExceptionSupport.h
new file mode 100644
index 00000000..63dd0b31
--- /dev/null
+++ b/NativeScript/runtime/NSExceptionSupport.h
@@ -0,0 +1,49 @@
+#ifndef NSExceptionSupport_h
+#define NSExceptionSupport_h
+
+// This header is only meaningful inside ObjC/ObjC++ translation units — it
+// declares an NSException category and Foundation-typed helpers. Do NOT include
+// it from a plain .cpp.
+#if defined(__OBJC__)
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// userInfo key under which synthesized escapes and the crash-flag exception
+// carry the captured JavaScript stack trace. This is the documented, stable
+// contract for crash-SDK integrations (its value matches the historical
+// userInfo key so existing consumers keep working).
+extern NSString* const TNSJavaScriptStackTraceKey;
+
+// userInfo key under which the escape-site ("escaped at") JS stack is carried,
+// present on synthesized escapes only when it differs from the origin stack.
+extern NSString* const TNSJavaScriptEscapeStackTraceKey;
+
+@interface NSException (NativeScript)
+
+// Returns the JavaScript stack trace associated with this exception, or nil.
+// Stable API for crash-SDK integrations: works uniformly for both synthesized
+// escapes and rethrown original native exceptions. Prefers the associated-object
+// stack (attached without mutating the exception's identity or userInfo),
+// falling back to userInfo[TNSJavaScriptStackTraceKey], then nil.
+- (NSString* _Nullable)tns_javascriptStackTrace;
+
+@end
+
+#ifdef __cplusplus
+namespace tns {
+
+// Attaches `stack` to `exception` as a copied associated object so
+// tns_javascriptStackTrace can surface it without mutating the exception's
+// identity or userInfo. No-op when either argument is nil.
+void SetJSStackOnException(id exception, NSString* stack);
+
+}  // namespace tns
+#endif
+
+NS_ASSUME_NONNULL_END
+
+#endif /* __OBJC__ */
+
+#endif /* NSExceptionSupport_h */
diff --git a/NativeScript/runtime/NSExceptionSupport.mm b/NativeScript/runtime/NSExceptionSupport.mm
new file mode 100644
index 00000000..5a1c40b3
--- /dev/null
+++ b/NativeScript/runtime/NSExceptionSupport.mm
@@ -0,0 +1,35 @@
+#import "NSExceptionSupport.h"
+#import <objc/runtime.h>
+
+NSString* const TNSJavaScriptStackTraceKey = @"JavaScriptStack";
+NSString* const TNSJavaScriptEscapeStackTraceKey = @"JavaScriptEscapeStack";
+
+// File-static, address-unique key for the associated-object slot.
+static const void* kTNSJSStackKey = &kTNSJSStackKey;
+
+@implementation NSException (NativeScript)
+
+- (NSString* _Nullable)tns_javascriptStackTrace {
+  NSString* associated = objc_getAssociatedObject(self, kTNSJSStackKey);
+  if (associated != nil) {
+    return associated;
+  }
+  id fromUserInfo = self.userInfo[TNSJavaScriptStackTraceKey];
+  if ([fromUserInfo isKindOfClass:[NSString class]]) {
+    return (NSString*)fromUserInfo;
+  }
+  return nil;
+}
+
+@end
+
+namespace tns {
+
+void SetJSStackOnException(id exception, NSString* stack) {
+  if (exception == nil || stack == nil) {
+    return;
+  }
+  objc_setAssociatedObject(exception, kTNSJSStackKey, stack, OBJC_ASSOCIATION_COPY_NONATOMIC);
+}
+
+}  // namespace tns
diff --git a/NativeScript/runtime/NativeScriptException.h b/NativeScript/runtime/NativeScriptException.h
index 48b05d58..8cfdfd1f 100644
--- a/NativeScript/runtime/NativeScriptException.h
+++ b/NativeScript/runtime/NativeScriptException.h
@@ -1,7 +1,9 @@
 #ifndef NativeScriptException_h
 #define NativeScriptException_h
 
+#include <atomic>
 #include <string>
+#include <vector>
 
 #include "Common.h"
 
@@ -14,18 +16,55 @@ class NativeScriptException {
                         const std::string& message);
   NativeScriptException(v8::Isolate* isolate, const std::string& message,
                         const std::string& name = "NativeScriptException");
+  // Carries a pre-built JS error object (e.g. one wrapping a native NSException
+  // via `nativeException`) so ReThrowToV8 surfaces exactly that object to the
+  // JS catch handler. `message` is used only for logging.
+  NativeScriptException(v8::Isolate* isolate, v8::Local<v8::Value> jsError,
+                        const std::string& message);
   ~NativeScriptException();
   void ReThrowToV8(v8::Isolate* isolate);
   const std::string& getMessage() const { return message_; }
   const std::string& getStackTrace() const { return stackTrace_; }
   static void OnUncaughtError(v8::Local<v8::Message> message,
                               v8::Local<v8::Value> error);
-  static void ShowErrorModal(v8::Isolate* isolate,
-                             const std::string& title,
+  // Isolate-level promise rejection callback (SetPromiseRejectCallback). Feeds
+  // the per-isolate PromiseRejectionTracker owned by Caches.
+  static void OnPromiseRejected(v8::PromiseRejectMessage message);
+  // Entry point for reporting an uncaught sync exception (message listener) and
+  // reportError. First dispatches an `error` ErrorEvent through the JS listener
+  // store; if a listener calls preventDefault() the report is fully handled and
+  // nothing else runs. Otherwise falls through to ReportFatalTail. `message`
+  // may be empty (rejections/reportError carry no v8::Message); `stackOverride`
+  // short-circuits stack derivation when non-empty; `logPrefix` distinguishes
+  // the log line while preserving the fatal-exception framing.
+  static void ReportToJsHandlersAndLog(v8::Isolate* isolate,
+                                       v8::Local<v8::Value> error,
+                                       v8::Local<v8::Message> message,
+                                       const std::string& stackOverride = "",
+                                       const std::string& logPrefix = "");
+  // Reports an unhandled promise rejection: dispatches a PromiseRejectionEvent
+  // (not an ErrorEvent) and, when unprevented, falls through to ReportFatalTail
+  // with the "Unhandled promise rejection:" prefix. Used by
+  // PromiseRejectionTracker::Drain on the main isolate.
+  static void ReportUnhandledRejection(v8::Isolate* isolate,
+                                       v8::Local<v8::Promise> promise,
+                                       v8::Local<v8::Value> reason,
+                                       const std::string& stackOverride = "");
+  // The terminal tail shared by the uncaught-error path, the rejection path and
+  // the JS `nativeReportFatal` handshake: calls the __on* shim and emits the
+  // fatal-exception log. Does NOT dispatch any event (the caller has already
+  // done so, or is reportError dispatching from JS), preventing recursion.
+  static void ReportFatalTail(v8::Isolate* isolate, v8::Local<v8::Value> error,
+                              v8::Local<v8::Message> message,
+                              const std::string& stackOverride = "",
+                              const std::string& logPrefix = "");
+  static std::string GetErrorStackTrace(
+      v8::Isolate* isolate, const v8::Local<v8::StackTrace>& stackTrace);
+  static void ShowErrorModal(v8::Isolate* isolate, const std::string& title,
                              const std::string& message,
                              const std::string& stackTrace);
-    static void SubmitConsoleErrorPayload(v8::Isolate* isolate,
-                                                                                const std::string& payload);
+  static void SubmitConsoleErrorPayload(v8::Isolate* isolate,
+                                        const std::string& payload);
 
  private:
   v8::Persistent<v8::Value>* javascriptException_;
@@ -33,8 +72,6 @@ class NativeScriptException {
   std::string message_;
   std::string stackTrace_;
   std::string fullMessage_;
-  static std::string GetErrorStackTrace(
-      v8::Isolate* isolate, const v8::Local<v8::StackTrace>& stackTrace);
   static std::string GetErrorMessage(v8::Isolate* isolate,
                                      v8::Local<v8::Value>& error,
                                      const std::string& prependMessage = "");
@@ -46,6 +83,70 @@ class NativeScriptException {
                                     const std::string& jsExceptionMessage);
 };
 
+// A promise that was rejected without a handler at a microtask checkpoint.
+// `reported` records that the rejection already reached the reporting tail;
+// Phase 1 discards reported entries, but the flag is retained so Phase 2 can
+// fire `rejectionhandled` for a handler added after reporting.
+struct PendingRejection {
+  v8::Global<v8::Promise> promise;
+  v8::Global<v8::Value> reason;
+  bool reported = false;
+};
+
+// Per-isolate tracker for unhandled promise rejections, owned by Caches.
+// Accessed only from the isolate's own thread (the reject callback runs during
+// the microtask checkpoint, the drain runs on the same runtime loop), so no
+// locking is required.
+class PromiseRejectionTracker {
+ public:
+  explicit PromiseRejectionTracker(v8::Isolate* isolate) : isolate_(isolate) {}
+
+  void OnReject(v8::Local<v8::Promise> promise, v8::Local<v8::Value> reason);
+  void OnHandlerAdded(v8::Local<v8::Promise> promise);
+  void Drain(v8::Local<v8::Context> context);
+  // Safe to call without holding the isolate lock: OnReject can run on any
+  // thread that holds the v8::Locker (e.g. a background-thread rejection), so
+  // the runloop observer polls this atomic instead of touching pending_.
+  bool HasPending() const {
+    return pendingCount_.load(std::memory_order_acquire) != 0;
+  }
+
+ private:
+  // The observer polls this atomic to decide whether a drain is needed. Both
+  // the still-to-report rejections and the queued rejectionhandled events count
+  // as work; reportedOutstanding_ does not (it only waits for a late handler).
+  void SyncPendingCount() {
+    pendingCount_.store(pending_.size() + pendingRejectionHandled_.size(),
+                        std::memory_order_release);
+  }
+  // Drop weak handles the GC has already cleared.
+  void PruneReportedOutstanding();
+
+  // A rejection that was already reported (unhandledrejection fired, prevented
+  // or not). The original reason is retained so a late rejectionhandled event
+  // carries it per spec; it is released when the entry is pruned or fired.
+  struct ReportedRejection {
+    v8::Global<v8::Promise> promise;
+    v8::Global<v8::Value> reason;
+  };
+
+  v8::Isolate* isolate_;
+  std::vector<PendingRejection> pending_;
+  // Reported rejections still outstanding. The promise handle is phantom-weak
+  // (SetWeak) so a GC'd promise drops the whole entry (reason included); a
+  // handler added later moves the entry into pendingRejectionHandled_.
+  std::vector<ReportedRejection> reportedOutstanding_;
+  // rejectionhandled events queued by OnHandlerAdded (which runs during a
+  // microtask checkpoint) to fire as a task on the next drain, per spec. Held
+  // strong so the promise survives until the event fires.
+  std::vector<ReportedRejection> pendingRejectionHandled_;
+  std::atomic<size_t> pendingCount_{0};
+  // Rejections that arrive while a drain is in progress are deferred to the
+  // next turn: Drain snapshots and clears `pending_` before iterating, so any
+  // OnReject during reporting accumulates into a fresh vector.
+  bool draining_ = false;
+};
+
 }  // namespace tns
 
 #endif /* NativeScriptException_h */
diff --git a/NativeScript/runtime/NativeScriptException.mm b/NativeScript/runtime/NativeScriptException.mm
index e891d727..83e5ed65 100644
--- a/NativeScript/runtime/NativeScriptException.mm
+++ b/NativeScript/runtime/NativeScriptException.mm
@@ -11,8 +11,12 @@
 #include <limits>
 #include <mutex>
 #include <sstream>
+#include "ArgConverter.h"
 #include "Caches.h"
+#include "DataWrapper.h"
+#include "ErrorEvents.h"
 #include "Helpers.h"
+#include "NSExceptionSupport.h"
 #include "Runtime.h"
 #include "RuntimeConfig.h"
 
@@ -87,26 +91,130 @@ static void ConsiderStackCandidate(PendingErrorDisplay& state, v8::Isolate* isol
   this->fullMessage_ =
       GetFullMessage(isolate, Exception::CreateMessage(isolate, error), this->message_);
 }
+NativeScriptException::NativeScriptException(Isolate* isolate, Local<Value> jsError,
+                                             const std::string& message) {
+  this->javascriptException_ = new Persistent<Value>(isolate, jsError);
+  this->message_ = message;
+  this->name_ = "NativeScriptException";
+}
+
 NativeScriptException::~NativeScriptException() { delete this->javascriptException_; }
 
 void NativeScriptException::OnUncaughtError(Local<v8::Message> message, Local<Value> error) {
   @try {
     Isolate* isolate = message->GetIsolate();
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Object> global = context->Global();
-    Local<Value> handler;
-    id value = Runtime::GetAppConfigValue("discardUncaughtJsExceptions");
-    bool isDiscarded = value ? [value boolValue] : false;
+    ReportToJsHandlersAndLog(isolate, error, message);
+  } @catch (NSException* exception) {
+    Log(@"OnUncaughtError: Caught exception during error handling: %@", exception);
+    @throw exception;
+  }
+}
+
+void NativeScriptException::ReportToJsHandlersAndLog(Isolate* isolate, Local<Value> error,
+                                                     Local<v8::Message> message,
+                                                     const std::string& stackOverride,
+                                                     const std::string& logPrefix) {
+  // First: give `error` event listeners a chance. If one prevents the default,
+  // the report is fully handled — no shim, no fatal log.
+  std::string messageString;
+  if (!message.IsEmpty()) {
+    messageString = tns::ToString(isolate, message->Get());
+  } else {
+    messageString = tns::ToString(isolate, error);
+  }
+  std::string stackForEvent = stackOverride;
+  if (stackForEvent.empty()) {
+    stackForEvent = tns::GetSmartStackTrace(isolate, nullptr, error);
+  }
+  if (ErrorEvents::DispatchError(isolate, error, messageString, stackForEvent)) {
+    return;
+  }
+
+  ReportFatalTail(isolate, error, message, stackOverride, logPrefix);
+}
+
+void NativeScriptException::ReportUnhandledRejection(Isolate* isolate, Local<Promise> promise,
+                                                     Local<Value> reason,
+                                                     const std::string& stackOverride) {
+  if (ErrorEvents::DispatchUnhandledRejection(isolate, promise, reason)) {
+    return;
+  }
+  ReportFatalTail(isolate, reason, Local<v8::Message>(), stackOverride,
+                  "Unhandled promise rejection:");
+}
+
+// Schedules an uncaught @throw on the runtime loop with a clean, V8-scope-free
+// stack. Throwing synchronously from here is unsafe: ReportFatalTail runs inside
+// V8 callbacks (message listener) or under the drain observer's V8 scopes. The
+// deferred block runs on a frame with no V8 scopes, so the uncaught NSException
+// terminates the app with a real crash report. Best-effort: silently returns if
+// the runtime/loop is gone (e.g. during teardown).
+static void ScheduleDeferredThrow(Isolate* isolate, NSException* e) {
+  Runtime* rt = Runtime::GetRuntime(isolate);
+  if (rt == nullptr) {
+    return;
+  }
+  CFRunLoopRef loop = rt->RuntimeLoop();
+  if (loop == nullptr) {
+    return;
+  }
+  CFRunLoopPerformBlock(loop, kCFRunLoopCommonModes, ^{
+    @throw e;
+  });
+  CFRunLoopWakeUp(loop);
+}
+
+void NativeScriptException::ReportFatalTail(Isolate* isolate, Local<Value> error,
+                                            Local<v8::Message> message,
+                                            const std::string& stackOverride,
+                                            const std::string& logPrefix) {
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Object> global = context->Global();
+
+  // A branded escapeException reaching the fatal tail (e.g. a listener did
+  // `throw interop.escapeException(x)`; the bootstrap routes listener throws to
+  // nativeReportFatal) is an explicit crash/forward request: skip shim + log and
+  // schedule the deferred @throw of the extracted NSException, regardless of the
+  // crash flag.
+  {
+    NSException* branded = ArgConverter::ExtractEscapedException(context, error);
+    if (branded != nil) {
+      ScheduleDeferredThrow(isolate, branded);
+      return;
+    }
+  }
+  Local<Value> handler;
+  id value = Runtime::GetAppConfigValue("discardUncaughtJsExceptions");
+  bool isDiscarded = value ? [value boolValue] : false;
 
-    std::string cbName = isDiscarded ? "__onDiscardedError" : "__onUncaughtError";
-    bool success = global->Get(context, tns::ToV8String(isolate, cbName)).ToLocal(&handler);
+  std::string cbName = isDiscarded ? "__onDiscardedError" : "__onUncaughtError";
+  bool success = global->Get(context, tns::ToV8String(isolate, cbName)).ToLocal(&handler);
 
-    std::string stackTrace = tns::GetSmartStackTrace(isolate, nullptr, error);
-    if (stackTrace.empty()) {
+  std::string stackTrace = stackOverride;
+  if (stackTrace.empty()) {
+    stackTrace = tns::GetSmartStackTrace(isolate, nullptr, error);
+  }
+  if (stackTrace.empty()) {
+    if (!message.IsEmpty()) {
       stackTrace = GetErrorStackTrace(isolate, message->GetStackTrace());
+    } else {
+      // Rejections carry no v8::Message; fall back to the reason's own stack.
+      stackTrace = GetErrorStackTrace(isolate, Exception::GetStackTrace(error));
     }
-    std::string fullMessage;
+  }
 
+  // Derive the human-readable message string, either from the v8::Message (sync
+  // exceptions) or from the reason value itself (rejections, no v8::Message).
+  auto messageOrReasonString = [&]() -> std::string {
+    if (!message.IsEmpty()) {
+      Local<v8::String> messageV8String = message->Get();
+      return tns::ToString(isolate, messageV8String);
+    }
+    return tns::ToString(isolate, error);
+  };
+
+  std::string fullMessage;
+  if (error->IsObject()) {
     auto errObject = error.As<Object>();
     auto fullMessageString = tns::ToV8String(isolate, "fullMessage");
     if (errObject->HasOwnProperty(context, fullMessageString).ToChecked()) {
@@ -117,56 +225,276 @@ static void ConsiderStackCandidate(PendingErrorDisplay& state, v8::Isolate* isol
         fullMessage = tns::ToString(isolate, fullMessage_);
       } else {
         // Fallback to regular message if fullMessage access fails
-        Local<v8::String> messageV8String = message->Get();
-        fullMessage = tns::ToString(isolate, messageV8String);
+        fullMessage = messageOrReasonString();
       }
     } else {
-      Local<v8::String> messageV8String = message->Get();
-      std::string messageString = tns::ToString(isolate, messageV8String);
-      fullMessage = messageString + "\n at \n" + stackTrace;
+      fullMessage = messageOrReasonString() + "\n at \n" + stackTrace;
     }
+  } else {
+    fullMessage = messageOrReasonString() + "\n at \n" + stackTrace;
+  }
 
-    if (success && handler->IsFunction()) {
-      if (error->IsObject()) {
-        // Try to set stackTrace property, but don't crash if it fails
-        bool stackTraceSet = error.As<Object>()
-                                 ->Set(context, tns::ToV8String(isolate, "stackTrace"),
-                                       tns::ToV8String(isolate, stackTrace))
-                                 .FromMaybe(false);
-        if (!stackTraceSet) {
-          Log(@"Warning: Failed to set stackTrace property on error object");
-        }
+  if (success && handler->IsFunction()) {
+    if (error->IsObject()) {
+      // Try to set stackTrace property, but don't crash if it fails
+      bool stackTraceSet = error.As<Object>()
+                               ->Set(context, tns::ToV8String(isolate, "stackTrace"),
+                                     tns::ToV8String(isolate, stackTrace))
+                               .FromMaybe(false);
+      if (!stackTraceSet) {
+        Log(@"Warning: Failed to set stackTrace property on error object");
       }
+    }
 
-      Local<v8::Function> errorHandlerFunc = handler.As<v8::Function>();
-      Local<Object> thiz = Object::New(isolate);
-      Local<Value> args[] = {error};
-      Local<Value> result;
-      TryCatch tc(isolate);
-      success = errorHandlerFunc->Call(context, thiz, 1, args).ToLocal(&result);
-      if (tc.HasCaught()) {
-        tns::LogError(isolate, tc);
-      }
+    Local<v8::Function> errorHandlerFunc = handler.As<v8::Function>();
+    Local<Object> thiz = Object::New(isolate);
+    Local<Value> args[] = {error};
+    Local<Value> result;
+    TryCatch tc(isolate);
+    success = errorHandlerFunc->Call(context, thiz, 1, args).ToLocal(&result);
+    if (tc.HasCaught()) {
+      tns::LogError(isolate, tc);
+    }
 
-      // Don't crash if error handler call failed - just log it
-      if (!success) {
-        Log(@"Warning: Error handler function call failed");
-      }
+    // Don't crash if error handler call failed - just log it
+    if (!success) {
+      Log(@"Warning: Error handler function call failed");
     }
+  }
 
-    if (!isDiscarded) {
-      Log(@"***** Fatal JavaScript exception *****\n");
-      Log(@"%s", fullMessage.c_str());
+  if (!isDiscarded) {
+    Log(@"***** Fatal JavaScript exception *****\n");
+    if (!logPrefix.empty()) {
+      Log(@"%s", logPrefix.c_str());
+    }
+    Log(@"%s", fullMessage.c_str());
+    if (!stackTrace.empty()) {
+      Log(@"%s", stackTrace.c_str());
+    }
+  } else {
+    if (!logPrefix.empty()) {
+      Log(@"%s", logPrefix.c_str());
+    }
+    Log(@"NativeScript discarding uncaught JS exception!");
+  }
+
+  // Opt-in (default off): after reporting, crash the app with a real native
+  // crash report by scheduling an uncaught @throw on a scope-free frame. Skipped
+  // when discarding (discardUncaughtJsExceptions is an explicit "do not crash").
+  if (!isDiscarded) {
+    id crashValue = Runtime::GetAppConfigValue("crashOnUncaughtJsExceptions");
+    bool shouldCrash = crashValue ? [crashValue boolValue] : false;
+    if (shouldCrash) {
+      NSString* reasonText = tns::ToNSString(fullMessage);
+      NSDictionary* userInfo =
+          stackTrace.empty() ? nil : @{TNSJavaScriptStackTraceKey : tns::ToNSString(stackTrace)};
+      NSException* fatal = [NSException exceptionWithName:@"NativeScriptFatalJSException"
+                                                   reason:reasonText
+                                                 userInfo:userInfo];
+      // Mirror the stack onto the associated object so the category accessor is
+      // uniform for crash-SDK hooks.
       if (!stackTrace.empty()) {
-        Log(@"%s", stackTrace.c_str());
+        tns::SetJSStackOnException(fatal, tns::ToNSString(stackTrace));
       }
-    } else {
-      Log(@"NativeScript discarding uncaught JS exception!");
+      ScheduleDeferredThrow(isolate, fatal);
+    }
+  }
+}
+
+void NativeScriptException::OnPromiseRejected(v8::PromiseRejectMessage message) {
+  Local<Promise> promise = message.GetPromise();
+  Isolate* isolate = promise->GetIsolate();
+  auto cache = Caches::Get(isolate);
+  if (cache == nullptr || cache->PromiseRejections == nullptr) {
+    return;
+  }
+
+  switch (message.GetEvent()) {
+    case v8::kPromiseRejectWithNoHandler:
+      cache->PromiseRejections->OnReject(promise, message.GetValue());
+      break;
+    case v8::kPromiseHandlerAddedAfterReject:
+      cache->PromiseRejections->OnHandlerAdded(promise);
+      break;
+    case v8::kPromiseResolveAfterResolved:
+    case v8::kPromiseRejectAfterResolved:
+      // Not relevant to unhandled-rejection tracking.
+      break;
+  }
+}
+
+void PromiseRejectionTracker::OnReject(Local<Promise> promise, Local<Value> reason) {
+  for (auto& entry : pending_) {
+    if (entry.promise.Get(isolate_)->SameValue(promise)) {
+      // Already tracked; refresh the reason for the latest rejection value.
+      entry.reason.Reset(isolate_, reason);
+      return;
+    }
+  }
+  PendingRejection entry;
+  entry.promise.Reset(isolate_, promise);
+  entry.reason.Reset(isolate_, reason);
+  entry.reported = false;
+  pending_.push_back(std::move(entry));
+  SyncPendingCount();
+}
+
+void PromiseRejectionTracker::PruneReportedOutstanding() {
+  reportedOutstanding_.erase(
+      std::remove_if(reportedOutstanding_.begin(), reportedOutstanding_.end(),
+                     [](const ReportedRejection& r) { return r.promise.IsEmpty(); }),
+      reportedOutstanding_.end());
+}
+
+void PromiseRejectionTracker::OnHandlerAdded(Local<Promise> promise) {
+  // A handler attached before the rejection was drained cancels the report.
+  for (auto it = pending_.begin(); it != pending_.end(); ++it) {
+    if (it->promise.Get(isolate_)->SameValue(promise)) {
+      pending_.erase(it);
+      SyncPendingCount();
+      return;
+    }
+  }
+  // Otherwise, if the rejection was already reported and the promise is still
+  // outstanding, queue a `rejectionhandled` event. OnHandlerAdded runs during a
+  // microtask checkpoint, but spec fires rejectionhandled as a task, so we defer
+  // to the next drain turn instead of dispatching synchronously.
+  for (auto it = reportedOutstanding_.begin(); it != reportedOutstanding_.end(); ++it) {
+    if (it->promise.IsEmpty()) {
+      continue;
+    }
+    if (it->promise.Get(isolate_)->SameValue(promise)) {
+      ReportedRejection queued;
+      // Re-anchor the promise strongly (the outstanding handle is weak) and
+      // carry the original reason so the event reports it per spec.
+      queued.promise.Reset(isolate_, promise);
+      queued.reason = std::move(it->reason);
+      reportedOutstanding_.erase(it);
+      pendingRejectionHandled_.push_back(std::move(queued));
+      SyncPendingCount();
+      PruneReportedOutstanding();
+      return;
     }
-  } @catch (NSException* exception) {
-    Log(@"OnUncaughtError: Caught exception during error handling: %@", exception);
-    @throw exception;
   }
+  PruneReportedOutstanding();
+}
+
+// Gives a worker's global `onerror` a chance to handle a rejected reason,
+// mirroring WorkerWrapper::CallOnErrorHandlers. Returns true when the handler
+// signalled it consumed the error (truthy return).
+static bool GiveWorkerOnErrorAChance(Isolate* isolate, Local<Context> context,
+                                     Local<Value> reason) {
+  Local<Object> global = context->Global();
+  Local<Value> onErrorVal;
+  if (!global->Get(context, tns::ToV8String(isolate, "onerror")).ToLocal(&onErrorVal)) {
+    return false;
+  }
+  if (onErrorVal.IsEmpty() || !onErrorVal->IsFunction()) {
+    return false;
+  }
+
+  Local<v8::Function> onErrorFunc = onErrorVal.As<v8::Function>();
+  Local<Value> args[1] = {reason};
+  Local<Value> result;
+  TryCatch tc(isolate);
+  bool success = onErrorFunc->Call(context, v8::Undefined(isolate), 1, args).ToLocal(&result);
+  return success && !result.IsEmpty() && result->BooleanValue(isolate);
+}
+
+void PromiseRejectionTracker::Drain(Local<Context> context) {
+  if (draining_) {
+    return;
+  }
+  draining_ = true;
+
+  // Fire queued rejectionhandled events first (they were deferred from a
+  // microtask checkpoint to run as a task on this drain turn), carrying the
+  // retained original rejection reason.
+  std::vector<ReportedRejection> handledSnapshot;
+  handledSnapshot.swap(pendingRejectionHandled_);
+
+  std::vector<PendingRejection> snapshot;
+  snapshot.swap(pending_);
+  SyncPendingCount();
+
+  auto cache = Caches::Get(isolate_);
+  bool isWorker = cache->isWorker;
+
+  for (auto& queued : handledSnapshot) {
+    if (queued.promise.IsEmpty()) {
+      continue;
+    }
+    @try {
+      Local<Promise> promise = queued.promise.Get(isolate_);
+      Local<Value> reason = queued.reason.IsEmpty() ? v8::Undefined(isolate_).As<Value>()
+                                                    : queued.reason.Get(isolate_);
+      ErrorEvents::DispatchRejectionHandled(isolate_, promise, reason);
+    } @catch (NSException* exception) {
+      Log(@"PromiseRejectionTracker: exception while firing rejectionhandled: %@", exception);
+    }
+  }
+
+  for (auto& entry : snapshot) {
+    if (entry.reported) {
+      continue;
+    }
+    entry.reported = true;
+
+    // The observer calling us holds live V8 scopes, so an NSException from the
+    // reporting path must not unwind past this frame — catch and log instead.
+    @try {
+      Local<Promise> promise = entry.promise.Get(isolate_);
+      Local<Value> reason = entry.reason.Get(isolate_);
+
+      std::string stack = tns::GetSmartStackTrace(isolate_, nullptr, reason);
+      if (stack.empty()) {
+        stack =
+            NativeScriptException::GetErrorStackTrace(isolate_, Exception::GetStackTrace(reason));
+      }
+
+      if (isWorker) {
+        // Dispatch the rejection event on the worker's own global first;
+        // preventDefault() there fully handles it. Only when unprevented fall
+        // through to the existing worker channel (worker-global onerror →
+        // forward to the main isolate's worker.onerror).
+        if (!ErrorEvents::DispatchUnhandledRejection(isolate_, promise, reason)) {
+          if (!GiveWorkerOnErrorAChance(isolate_, context, reason)) {
+            Runtime* runtime = Runtime::GetRuntime(isolate_);
+            if (runtime != nullptr) {
+              int workerId = runtime->WorkerId();
+              bool found = false;
+              auto state = Caches::Workers->Get(workerId, found);
+              if (found && state != nullptr) {
+                auto* worker = static_cast<WorkerWrapper*>(state->UserData());
+                if (worker != nullptr) {
+                  std::string reasonMessage = tns::ToString(isolate_, reason);
+                  worker->PassUncaughtRejectionToMain(reasonMessage, "Worker script", stack, 1);
+                }
+              }
+            }
+          }
+        }
+      } else {
+        NativeScriptException::ReportUnhandledRejection(isolate_, promise, reason, stack);
+      }
+
+      // The rejection has now been reported (unhandledrejection fired, prevented
+      // or not). Keep the promise as a phantom-weak outstanding entry so a
+      // handler attached later fires rejectionhandled; a GC'd promise drops out
+      // on its own.
+      ReportedRejection outstanding;
+      outstanding.promise = std::move(entry.promise);
+      outstanding.reason = std::move(entry.reason);
+      reportedOutstanding_.push_back(std::move(outstanding));
+      reportedOutstanding_.back().promise.SetWeak();
+    } @catch (NSException* exception) {
+      Log(@"PromiseRejectionTracker: exception while reporting rejection: %@", exception);
+    }
+  }
+
+  PruneReportedOutstanding();
+
+  draining_ = false;
 }
 
 void NativeScriptException::ReThrowToV8(Isolate* isolate) {
diff --git a/NativeScript/runtime/PromiseProxy.cpp b/NativeScript/runtime/PromiseProxy.cpp
index 5cce77de..fe8fe48f 100644
--- a/NativeScript/runtime/PromiseProxy.cpp
+++ b/NativeScript/runtime/PromiseProxy.cpp
@@ -2,6 +2,7 @@
 
 #include <CoreFoundation/CoreFoundation.h>
 
+#include "BuiltinLoader.h"
 #include "Helpers.h"
 #include "Runtime.h"
 
@@ -14,104 +15,32 @@ namespace tns {
 // marshaled back to its creating thread only when that thread is the runtime
 // loop; a promise created elsewhere settles on whichever thread resolves it.
 static void IsRuntimeRunloopCallback(const FunctionCallbackInfo<Value>& args) {
-    Runtime* runtime = Runtime::GetRuntime(args.GetIsolate());
-    bool isRuntimeLoop = runtime != nullptr && CFRunLoopGetCurrent() == runtime->RuntimeLoop();
-    args.GetReturnValue().Set(isRuntimeLoop);
+  Runtime* runtime = Runtime::GetRuntime(args.GetIsolate());
+  bool isRuntimeLoop =
+      runtime != nullptr && CFRunLoopGetCurrent() == runtime->RuntimeLoop();
+  args.GetReturnValue().Set(isRuntimeLoop);
 }
 
 void PromiseProxy::Init(v8::Local<v8::Context> context) {
-    std::string source = R"(
-        // Run a Promise's callbacks on the thread that created it, but only when
-        // that thread is the runtime loop. A Promise created on a background
-        // thread settles on whichever thread resolves it, because the background
-        // run loop may be dormant and marshaling a resolution to it would hang.
-        (function(isRuntimeRunloop) {
-            global.Promise = new Proxy(global.Promise, {
-                construct: function(target, args) {
-                    let origFunc = args[0];
-                    let runloop = CFRunLoopGetCurrent();
-                    let originIsRuntimeLoop = isRuntimeRunloop();
+  Isolate* isolate = context->GetIsolate();
 
-                    let promise = new target(function(resolve, reject) {
-                        function isFulfilled() {
-                            return !resolve;
-                        }
-                        function markFulfilled() {
-                            origFunc = null;
-                            resolve = null;
-                            reject = null;
-                        }
-                        origFunc(value => {
-                            if (isFulfilled()) {
-                                return;
-                            }
-                            const resolveCall = resolve.bind(this, value);
-                            if (!originIsRuntimeLoop || runloop === CFRunLoopGetCurrent()) {
-                                markFulfilled();
-                                resolveCall();
-                            } else {
-                                CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, resolveCall);
-                                CFRunLoopWakeUp(runloop);
-                                markFulfilled();
-                            }
-                        }, reason => {
-                            if (isFulfilled()) {
-                                return;
-                            }
-                            const rejectCall = reject.bind(this, reason);
-                            if (!originIsRuntimeLoop || runloop === CFRunLoopGetCurrent()) {
-                                markFulfilled();
-                                rejectCall();
-                            } else {
-                                CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, rejectCall);
-                                CFRunLoopWakeUp(runloop);
-                                markFulfilled();
-                            }
-                        });
-                    });
+  Local<Value> result;
+  bool success = BuiltinLoader::RunBuiltin(context, BuiltinId::kPromiseProxy)
+                     .ToLocal(&result);
+  tns::Assert(success && result->IsFunction(), isolate);
 
-                    return new Proxy(promise, {
-                        get: function(target, name) {
-                            let orig = target[name];
-                            if (name === "then" || name === "catch" || name === "finally") {
-                                return orig.bind(target);
-                            }
-                            return typeof orig === 'function' ? function(x) {
-                                if (!originIsRuntimeLoop || runloop === CFRunLoopGetCurrent()) {
-                                    orig.bind(target, x)();
-                                    return target;
-                                }
-                                CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, orig.bind(target, x));
-                                CFRunLoopWakeUp(runloop);
-                                return target;
-                            } : orig;
-                        }
-                    });
-                }
-            });
-        })
-    )";
+  Local<v8::Function> installProxy = result.As<v8::Function>();
 
-    Isolate* isolate = context->GetIsolate();
+  Local<v8::Function> isRuntimeRunloop;
+  success = v8::Function::New(context, IsRuntimeRunloopCallback)
+                .ToLocal(&isRuntimeRunloop);
+  tns::Assert(success, isolate);
 
-    Local<Script> script;
-    bool success = Script::Compile(context, tns::ToV8String(isolate, source)).ToLocal(&script);
-    tns::Assert(success && !script.IsEmpty(), isolate);
-
-    Local<Value> result;
-    success = script->Run(context).ToLocal(&result);
-    tns::Assert(success && result->IsFunction(), isolate);
-
-    Local<v8::Function> installProxy = result.As<v8::Function>();
-
-    Local<v8::Function> isRuntimeRunloop;
-    success = v8::Function::New(context, IsRuntimeRunloopCallback).ToLocal(&isRuntimeRunloop);
-    tns::Assert(success, isolate);
-
-    Local<Value> installArgs[] = { isRuntimeRunloop };
-    Local<Value> installResult;
-    success = installProxy->Call(context, context->Global(), 1, installArgs).ToLocal(&installResult);
-    tns::Assert(success, isolate);
+  Local<Value> installArgs[] = {isRuntimeRunloop};
+  Local<Value> installResult;
+  success = installProxy->Call(context, context->Global(), 1, installArgs)
+                .ToLocal(&installResult);
+  tns::Assert(success, isolate);
 }
 
-}
+}  // namespace tns
diff --git a/NativeScript/runtime/Runtime.h b/NativeScript/runtime/Runtime.h
index 92d95dba..f8e1d677 100644
--- a/NativeScript/runtime/Runtime.h
+++ b/NativeScript/runtime/Runtime.h
@@ -78,10 +78,15 @@ class Runtime {
 
   static void PerformanceNowCallback(
       const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DrainRejectionsObserver(CFRunLoopObserverRef observer,
+                                      CFRunLoopActivity activity, void* info);
   v8::Isolate* isolate_;
   std::unique_ptr<ModuleInternal> moduleInternal_;
   int workerId_;
   CFRunLoopRef runtimeLoop_;
+  // Drains unhandled promise rejections once per runloop turn
+  // (kCFRunLoopBeforeWaiting). Torn down before isolate disposal in ~Runtime.
+  CFRunLoopObserverRef rejectionObserver_ = nullptr;
   double startTime;
   double realtimeOrigin;
   // TODO: refactor this. This is only needed because, during program
diff --git a/NativeScript/runtime/Runtime.mm b/NativeScript/runtime/Runtime.mm
index 05df3e36..cc613fb0 100644
--- a/NativeScript/runtime/Runtime.mm
+++ b/NativeScript/runtime/Runtime.mm
@@ -2,9 +2,12 @@
 #include <chrono>
 #include <string>
 #include "ArgConverter.h"
+#include "BuiltinLoader.h"
 #include "Caches.h"
 #include "Console.h"
 #include "Constants.h"
+#include "ErrorEvents.h"
+#include "Events.h"
 #include "Helpers.h"
 #include "InlineFunctions.h"
 #include "Interop.h"
@@ -183,6 +186,14 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
 }
 
 Runtime::~Runtime() {
+  // Tear the rejection observer down before any isolate teardown: it references
+  // the isolate and reads Caches, both of which are invalidated below.
+  if (rejectionObserver_ != nullptr) {
+    CFRunLoopObserverInvalidate(rejectionObserver_);
+    CFRelease(rejectionObserver_);
+    rejectionObserver_ = nullptr;
+  }
+
   auto currentIsolate = this->isolate_;
   {
     // make sure we remove the isolate from the list of active isolates first
@@ -326,85 +337,34 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
   isolate->SetHostInitializeImportMetaObjectCallback(InitializeImportMetaObject);
 
   isolate->AddMessageListener(NativeScriptException::OnUncaughtError);
+  isolate->SetPromiseRejectCallback(NativeScriptException::OnPromiseRejected);
 
   Local<Context> context = Context::New(isolate, nullptr, globalTemplate);
   context->Enter();
 
+  // Drain tracked unhandled promise rejections once per runloop turn, just
+  // before the loop sleeps. The info pointer is the isolate; the callback
+  // re-validates liveness because the isolate may be torn down between turns.
+  CFRunLoopObserverContext observerContext = {0, isolate, nullptr, nullptr, nullptr};
+  rejectionObserver_ =
+      CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopBeforeWaiting, /*repeats*/ true,
+                              /*order*/ 0, Runtime::DrainRejectionsObserver, &observerContext);
+  CFRunLoopAddObserver(runtimeLoop_, rejectionObserver_, kCFRunLoopCommonModes);
+
   DefineGlobalObject(context, isWorker);
   DefineCollectFunction(context);
   PromiseProxy::Init(context);
+  Events::Init(context);
+  ErrorEvents::Init(context);
   Console::Init(context);
   WeakRef::Init(context);
 
-  auto blob_methods = R"js(
-    const BLOB_STORE = new Map();
-    URL.createObjectURL = function (object, options = null) {
-        try {
-            if (object instanceof Blob || object instanceof File) {
-                const id = NSUUID.UUID().UUIDString.toLowerCase();
-                const ret = `blob:nativescript/${id}`;
-                BLOB_STORE.set(ret, {
-                    blob: object,
-                    type: object?.type,
-                    ext: options?.ext,
-                });
-                return ret;
-            }
-        } catch (error) {
-            return null;
-        }
-        return null;
-    };
-    URL.revokeObjectURL = function (url) {
-        BLOB_STORE.delete(url);
-    };
-    const InternalAccessor = class {};
-    InternalAccessor.getData = function (url) {
-        return BLOB_STORE.get(url);
-    };
-    URL.InternalAccessor = InternalAccessor;
-    Object.defineProperty(URL.prototype, 'searchParams', {
-        get() {
-            if (this._searchParams == null) {
-                this._searchParams = new URLSearchParams(this.search);
-                Object.defineProperty(this._searchParams, '_url', {
-                    enumerable: false,
-                    writable: false,
-                    value: this,
-                });
-                this._searchParams._append = this._searchParams.append;
-                this._searchParams.append = function (name, value) {
-                    this._append(name, value);
-                    this._url.search = this.toString();
-                };
-                this._searchParams._delete = this._searchParams.delete;
-                this._searchParams.delete = function (name) {
-                    this._delete(name);
-                    this._url.search = this.toString();
-                };
-                this._searchParams._set = this._searchParams.set;
-                this._searchParams.set = function (name, value) {
-                    this._set(name, value);
-                    this._url.search = this.toString();
-                };
-                this._searchParams._sort = this._searchParams.sort;
-                this._searchParams.sort = function () {
-                    this._sort();
-                    this._url.search = this.toString();
-                };
-            }
-            return this._searchParams;
-        },
-    });
-    )js";
-
-  v8::Local<v8::Script> script;
-  auto done = v8::Script::Compile(context, ToV8String(isolate, blob_methods)).ToLocal(&script);
-
-  v8::Local<v8::Value> outVal;
-  if (done) {
-    done = script->Run(context).ToLocal(&outVal);
-  }
+  // URL blob support (internal/blob-url.js); failures are tolerated, matching
+  // the previous compile-and-run-if-possible behavior.
+  v8::Local<v8::Value> blobMethodsResult;
+  bool blobMethodsOk =
+      BuiltinLoader::RunBuiltin(context, BuiltinId::kBlobUrl).ToLocal(&blobMethodsResult);
+  (void)blobMethodsOk;
 
   this->moduleInternal_ = std::make_unique<ModuleInternal>(context);
 
@@ -603,6 +563,28 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
                       drainMicrotaskTemplate);
 }
 
+void Runtime::DrainRejectionsObserver(CFRunLoopObserverRef observer, CFRunLoopActivity activity,
+                                      void* info) {
+  Isolate* isolate = static_cast<Isolate*>(info);
+  if (!Runtime::IsAlive(isolate)) {
+    return;
+  }
+  auto cache = Caches::Get(isolate);
+  // HasPending is an atomic read: OnReject can run on any thread holding the
+  // v8::Locker, so pending_ itself must only be touched under the lock below.
+  if (!cache->IsValid() || cache->PromiseRejections == nullptr ||
+      !cache->PromiseRejections->HasPending()) {
+    return;
+  }
+
+  v8::Locker locker(isolate);
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+  Local<Context> context = cache->GetContext();
+  Context::Scope context_scope(context);
+  cache->PromiseRejections->Drain(context);
+}
+
 bool Runtime::IsAlive(const Isolate* isolate) {
   // speedup lookup by avoiding locking if thread locals match
   // note: this can be a problem when the Runtime is deleted in a different thread that it was
diff --git a/NativeScript/runtime/TSHelpers.cpp b/NativeScript/runtime/TSHelpers.cpp
index a1392463..095e8825 100644
--- a/NativeScript/runtime/TSHelpers.cpp
+++ b/NativeScript/runtime/TSHelpers.cpp
@@ -1,5 +1,8 @@
 #include "TSHelpers.h"
+
 #include <string>
+
+#include "BuiltinLoader.h"
 #include "Helpers.h"
 
 using namespace v8;
@@ -7,140 +10,29 @@ using namespace v8;
 namespace tns {
 
 void TSHelpers::Init(Local<Context> context) {
-    // The purpose of this script is to handle the "new" operator when extending native classes:
-    //
-    // var InheritingClass = (function (_super) {
-    //     __extends(InheritingClass, _super);
-    //     function InheritingClass() {
-    //         return _super !== null && _super.apply(this, arguments) || this; // <---- _super.apply and _super.call methods will invoke the original .extend() method on the derived class
-    //     }
-    //     return InheritingClass;
-    // }(BaseClass));
-    // var obj = new InheritingClass();
-
-    std::string source =
-        "(() => {"
-        "    var __originalExtends = global.__extends;"
-        "    var __extends = (Child, Parent) => {"
-        "        var extendingNativeClass = !!Parent.extend && (Parent.extend.toString().indexOf(\"[native code]\") > -1);"
-        "        if (!extendingNativeClass) {"
-        "            __extends_ts(Child, Parent);"
-        "            return;"
-        "        }"
-        ""
-        "        if (Parent.__isPrototypeImplementationObject) {"
-        "            throw new Error(\"Can not extend an already extended native object.\");"
-        "        }"
-        ""
-        "        function extend(thiz) {"
-        "            var child = thiz.__proto__.__child;"
-        "            if (!child.__extended) {"
-        "                var parent = thiz.__proto__.__parent;"
-        "                child.__extended = parent.extend(child.prototype, {"
-        "                    name: child.name,"
-        "                    protocols: child.ObjCProtocols || [],"
-        "                    exposedMethods: child.ObjCExposedMethods || {}"
-        "                });"
-        "                child[Symbol.hasInstance] = function (instance) {"
-        "                    return instance instanceof this.__extended;"
-        "                }"
-        "            }"
-        "            return child.__extended;"
-        "        }"
-        ""
-        "        Parent.call = function (thiz) {"
-        "            var Extended = extend(thiz);"
-        "            thiz.__container__ = true;"
-        "            if (arguments.length > 1) {"
-        "                thiz.__proto__ = new (Function.prototype.bind.apply(Extended, [null].concat(Array.prototype.slice.call(arguments, 1))));"
-        "            } else {"
-        "                thiz.__proto__ = new Extended()"
-        "            }"
-        "            return thiz.__proto__;"
-        "        };"
-        ""
-        "        Parent.apply = function (thiz, args) {"
-        "            var Extended = extend(thiz);"
-        "            thiz.__container__ = true;"
-        "            if (args && args.length > 0) {"
-        "                thiz.__proto__ = new (Function.prototype.bind.apply(Extended, [null].concat(args)));"
-        "            } else {"
-        "                thiz.__proto__ = new Extended();"
-        "            }"
-        "            return thiz.__proto__;"
-        "        };"
-        ""
-        "        __extends_ns(Child, Parent);"
-        "        Child.__isPrototypeImplementationObject = true;"
-        "        Child.__proto__ = Parent;"
-        "        Child.prototype.__parent = Parent;"
-        "        Child.prototype.__child = Child;"
-        ""
-        "        if (__originalExtends) {"
-        "            __originalExtends(Child, Parent);"
-        "        }"
-        "    };"
-        ""
-        "    var __extends_ts = function (child, parent) {"
-        "        extendStaticFunctions(child, parent);"
-        "        assignPrototypeFromParentToChild(parent, child);"
-        "    };"
-        ""
-        "    var __extends_ns = function (child, parent) {"
-        "        if (!parent.extend) {"
-        "            assignPropertiesFromParentToChild(parent, child);"
-        "        }"
-        ""
-        "        assignPrototypeFromParentToChild(parent, child);"
-        "    };"
-        ""
-        "    var extendStaticFunctions ="
-        "        Object.setPrototypeOf"
-        "        || (hasInternalProtoProperty() && function (child, parent) { child.__proto__ = parent; })"
-        "        || assignPropertiesFromParentToChild;"
-        ""
-        "    function hasInternalProtoProperty() {"
-        "        return { __proto__: [] } instanceof Array;"
-        "    }"
-        ""
-        "    function assignPropertiesFromParentToChild(parent, child) {"
-        "        for (var property in parent) {"
-        "            if (parent.hasOwnProperty(property)) {"
-        "                child[property] = parent[property];"
-        "            }"
-        "        }"
-        "    }"
-        ""
-        "    function assignPrototypeFromParentToChild(parent, child) {"
-        "        function __() {"
-        "            this.constructor = child;"
-        "        }"
-        ""
-        "        if (parent === null) {"
-        "            child.prototype = Object.create(null);"
-        "        } else {"
-        "            __.prototype = parent.prototype;"
-        "            child.prototype = new __();"
-        "        }"
-        "    }"
-        ""
-        "    Object.defineProperty(global, \"__extends\", { value: __extends, writable: false });"
-        "})()";
+  // The purpose of this script is to handle the "new" operator when extending
+  // native classes:
+  //
+  // var InheritingClass = (function (_super) {
+  //     __extends(InheritingClass, _super);
+  //     function InheritingClass() {
+  //         return _super !== null && _super.apply(this, arguments) || this; //
+  //         <---- _super.apply and _super.call methods will invoke the original
+  //         .extend() method on the derived class
+  //     }
+  //     return InheritingClass;
+  // }(BaseClass));
+  // var obj = new InheritingClass();
 
-    Isolate* isolate = context->GetIsolate();
-    Local<Script> script;
-    TryCatch tc(isolate);
-    if (!Script::Compile(context, tns::ToV8String(isolate, source.c_str())).ToLocal(&script) && tc.HasCaught()) {
-        tns::LogError(isolate, tc);
-        tns::Assert(false, isolate);
-    }
-    tns::Assert(!script.IsEmpty(), isolate);
-
-    Local<Value> result;
-    if (!script->Run(context).ToLocal(&result) && tc.HasCaught()) {
-        tns::LogError(isolate, tc);
-        tns::Assert(false, isolate);
-    }
+  Isolate* isolate = context->GetIsolate();
+  TryCatch tc(isolate);
+  Local<Value> result;
+  if (!BuiltinLoader::RunBuiltin(context, BuiltinId::kTsHelpers)
+           .ToLocal(&result) &&
+      tc.HasCaught()) {
+    tns::LogError(isolate, tc);
+    tns::Assert(false, isolate);
+  }
 }
 
-}
+}  // namespace tns
diff --git a/NativeScript/runtime/WeakRef.cpp b/NativeScript/runtime/WeakRef.cpp
index adff449f..14550585 100644
--- a/NativeScript/runtime/WeakRef.cpp
+++ b/NativeScript/runtime/WeakRef.cpp
@@ -1,4 +1,6 @@
 #include "WeakRef.h"
+
+#include "BuiltinLoader.h"
 #include "Helpers.h"
 
 using namespace v8;
@@ -6,27 +8,12 @@ using namespace v8;
 namespace tns {
 
 void WeakRef::Init(Local<Context> context) {
-    Isolate* isolate = context->GetIsolate();
-
-    std::string source = R"(
-        global.WeakRef.prototype.get = global.WeakRef.prototype.deref;
-        global.WeakRef.prototype.__hasWarnedAboutClear = false;
-        global.WeakRef.prototype.clear = () => {
-            if(global.WeakRef.prototype.__hasWarnedAboutClear) {
-                return;
-            }
-            global.WeakRef.prototype.__hasWarnedAboutClear = true;
-            console.warn('WeakRef.clear() is non-standard and has been deprecated. It does nothing and the call can be safely removed.');
-        }
-    )";
-
-    Local<Script> script;
-    bool success = Script::Compile(context, tns::ToV8String(isolate, source)).ToLocal(&script);
-    tns::Assert(success && !script.IsEmpty(), isolate);
+  Isolate* isolate = context->GetIsolate();
 
-    Local<Value> result;
-    success = script->Run(context).ToLocal(&result);
-    tns::Assert(success, isolate);
+  Local<Value> result;
+  bool success =
+      BuiltinLoader::RunBuiltin(context, BuiltinId::kWeakRef).ToLocal(&result);
+  tns::Assert(success, isolate);
 }
 
-}
\ No newline at end of file
+}  // namespace tns
diff --git a/NativeScript/runtime/WorkerWrapper.mm b/NativeScript/runtime/WorkerWrapper.mm
index 65f3855c..e8748388 100644
--- a/NativeScript/runtime/WorkerWrapper.mm
+++ b/NativeScript/runtime/WorkerWrapper.mm
@@ -321,6 +321,22 @@
                                                           const std::string& source,
                                                           const std::string& stackTrace,
                                                           int lineNumber, bool async) {
+  this->ForwardErrorPayloadToMain(message, source, stackTrace, lineNumber, async);
+}
+
+void WorkerWrapper::PassUncaughtRejectionToMain(const std::string& message,
+                                                const std::string& source,
+                                                const std::string& stackTrace, int lineNumber,
+                                                bool async) {
+  if (this->isTerminating_ || this->isDisposed_) {
+    return;
+  }
+  this->ForwardErrorPayloadToMain(message, source, stackTrace, lineNumber, async);
+}
+
+void WorkerWrapper::ForwardErrorPayloadToMain(const std::string& message, const std::string& source,
+                                              const std::string& stackTrace, int lineNumber,
+                                              bool async) {
   auto runtime = static_cast<Runtime*>(mainIsolate_->GetData(Constants::RUNTIME_SLOT));
   if (runtime == nullptr) {
     return;
diff --git a/NativeScript/runtime/js/blob-url.js b/NativeScript/runtime/js/blob-url.js
new file mode 100644
index 00000000..6f414f85
--- /dev/null
+++ b/NativeScript/runtime/js/blob-url.js
@@ -0,0 +1,59 @@
+const BLOB_STORE = new Map();
+URL.createObjectURL = function (object, options = null) {
+    try {
+        if (object instanceof Blob || object instanceof File) {
+            const id = NSUUID.UUID().UUIDString.toLowerCase();
+            const ret = `blob:nativescript/${id}`;
+            BLOB_STORE.set(ret, {
+                blob: object,
+                type: object?.type,
+                ext: options?.ext,
+            });
+            return ret;
+        }
+    } catch (error) {
+        return null;
+    }
+    return null;
+};
+URL.revokeObjectURL = function (url) {
+    BLOB_STORE.delete(url);
+};
+const InternalAccessor = class {};
+InternalAccessor.getData = function (url) {
+    return BLOB_STORE.get(url);
+};
+URL.InternalAccessor = InternalAccessor;
+Object.defineProperty(URL.prototype, 'searchParams', {
+    get() {
+        if (this._searchParams == null) {
+            this._searchParams = new URLSearchParams(this.search);
+            Object.defineProperty(this._searchParams, '_url', {
+                enumerable: false,
+                writable: false,
+                value: this,
+            });
+            this._searchParams._append = this._searchParams.append;
+            this._searchParams.append = function (name, value) {
+                this._append(name, value);
+                this._url.search = this.toString();
+            };
+            this._searchParams._delete = this._searchParams.delete;
+            this._searchParams.delete = function (name) {
+                this._delete(name);
+                this._url.search = this.toString();
+            };
+            this._searchParams._set = this._searchParams.set;
+            this._searchParams.set = function (name, value) {
+                this._set(name, value);
+                this._url.search = this.toString();
+            };
+            this._searchParams._sort = this._searchParams.sort;
+            this._searchParams.sort = function () {
+                this._sort();
+                this._url.search = this.toString();
+            };
+        }
+        return this._searchParams;
+    },
+});
diff --git a/NativeScript/runtime/js/class-extends.js b/NativeScript/runtime/js/class-extends.js
new file mode 100644
index 00000000..40984f24
--- /dev/null
+++ b/NativeScript/runtime/js/class-extends.js
@@ -0,0 +1,13 @@
+(function() { 
+    function __extends(d, b) { 
+         for (var p in b) {
+             if (b.hasOwnProperty(p)) {
+                 d[p] = b[p];
+             }
+         }
+         function __() { this.constructor = d; }
+         d.prototype = b === null ? Object.create(b) : 
+(__.prototype = b.prototype, new __());
+    } 
+    return __extends;
+})()
diff --git a/NativeScript/runtime/js/error-events.js b/NativeScript/runtime/js/error-events.js
new file mode 100644
index 00000000..13fe428b
--- /dev/null
+++ b/NativeScript/runtime/js/error-events.js
@@ -0,0 +1,81 @@
+(function (globalTarget, nativeReportFatal) {
+  "use strict";
+  var g = globalThis;
+  var Event = g.Event;
+
+  function ErrorEvent(type, opts) {
+    opts = opts || {};
+    Event.call(this, type, opts);
+    this.message = opts.message !== undefined ? String(opts.message) : "";
+    this.filename = opts.filename !== undefined ? String(opts.filename) : "";
+    this.lineno = opts.lineno !== undefined ? (opts.lineno | 0) : 0;
+    this.colno = opts.colno !== undefined ? (opts.colno | 0) : 0;
+    this.error = opts.error !== undefined ? opts.error : null;
+  }
+  ErrorEvent.prototype = Object.create(Event.prototype);
+  ErrorEvent.prototype.constructor = ErrorEvent;
+
+  function PromiseRejectionEvent(type, opts) {
+    opts = opts || {};
+    Event.call(this, type, opts);
+    this.promise = opts.promise;
+    this.reason = opts.reason;
+  }
+  PromiseRejectionEvent.prototype = Object.create(Event.prototype);
+  PromiseRejectionEvent.prototype.constructor = PromiseRejectionEvent;
+
+  // A listener that throws must not stop other listeners: route the thrown
+  // value to the native fatal tail instead of ever recursively dispatching
+  // another `error` event from inside dispatch.
+  globalTarget._installListenerErrorReporter(function (e) {
+    try { nativeReportFatal(e, (e && e.stack) || ""); } catch (ignored) {}
+  });
+
+  g.reportError = function (e) {
+    if (arguments.length === 0) {
+      throw new TypeError("Failed to execute 'reportError': 1 argument required, but only 0 present.");
+    }
+    var ev = new ErrorEvent("error", {
+      message: (e && e.message !== undefined && e.message !== null) ? String(e.message) : String(e),
+      error: e,
+      cancelable: true
+    });
+    if (globalTarget.dispatchEvent(ev)) {
+      nativeReportFatal(e, (e && e.stack) || "");
+    }
+  };
+
+  g.ErrorEvent = ErrorEvent;
+  g.PromiseRejectionEvent = PromiseRejectionEvent;
+
+  // Closures called by C++. They never look up globalThis.dispatchEvent, so
+  // they keep working even if app code overwrites it.
+  function dispatchErrorEvent(error, message, stack) {
+    var ev = new ErrorEvent("error", {
+      message: message !== undefined && message !== null ? String(message) : "",
+      error: error,
+      cancelable: true
+    });
+    globalTarget.dispatchEvent(ev);
+    return ev.defaultPrevented;
+  }
+  function dispatchUnhandledRejection(promise, reason) {
+    var ev = new PromiseRejectionEvent("unhandledrejection", {
+      promise: promise,
+      reason: reason,
+      cancelable: true
+    });
+    globalTarget.dispatchEvent(ev);
+    return ev.defaultPrevented;
+  }
+  function dispatchRejectionHandled(promise, reason) {
+    var ev = new PromiseRejectionEvent("rejectionhandled", {
+      promise: promise,
+      reason: reason,
+      cancelable: false
+    });
+    globalTarget.dispatchEvent(ev);
+  }
+
+  return [dispatchErrorEvent, dispatchUnhandledRejection, dispatchRejectionHandled];
+})
diff --git a/NativeScript/runtime/js/events.js b/NativeScript/runtime/js/events.js
new file mode 100644
index 00000000..8cb1a78b
--- /dev/null
+++ b/NativeScript/runtime/js/events.js
@@ -0,0 +1,129 @@
+(function () {
+  "use strict";
+  var g = globalThis;
+
+  function Event(type, opts) {
+    opts = opts || {};
+    this.type = String(type);
+    this.bubbles = !!opts.bubbles;
+    this.cancelable = !!opts.cancelable;
+    this.composed = !!opts.composed;
+    this.defaultPrevented = false;
+    this.target = null;
+    this.currentTarget = null;
+    this._stopPropagation = false;
+    this._stopImmediate = false;
+  }
+  Event.prototype.preventDefault = function () {
+    if (this.cancelable) { this.defaultPrevented = true; }
+  };
+  Event.prototype.stopPropagation = function () { this._stopPropagation = true; };
+  Event.prototype.stopImmediatePropagation = function () {
+    this._stopPropagation = true;
+    this._stopImmediate = true;
+  };
+
+  // A listener that throws must not stop other listeners: route the thrown
+  // value to the native fatal tail instead of ever recursively dispatching
+  // another `error` event from inside dispatch. The error-events layer
+  // installs the real reporter via _installListenerErrorReporter (before any
+  // user code runs); until then a thrown listener is swallowed.
+  var reportListenerError = function (e) {};
+
+  function EventTargetImpl() { this._listeners = Object.create(null); }
+  EventTargetImpl.prototype.addEventListener = function (type, callback, options) {
+    if (callback === null || callback === undefined) { return; }
+    type = String(type);
+    var capture = false, once = false;
+    if (typeof options === "boolean") {
+      capture = options;
+    } else if (options && typeof options === "object") {
+      capture = !!options.capture;
+      once = !!options.once;
+    }
+    var list = this._listeners[type];
+    if (!list) { list = this._listeners[type] = []; }
+    for (var i = 0; i < list.length; i++) {
+      if (list[i].callback === callback && list[i].capture === capture) { return; }
+    }
+    list.push({ callback: callback, once: once, capture: capture });
+  };
+  EventTargetImpl.prototype.removeEventListener = function (type, callback, options) {
+    type = String(type);
+    var capture = false;
+    if (typeof options === "boolean") {
+      capture = options;
+    } else if (options && typeof options === "object") {
+      capture = !!options.capture;
+    }
+    var list = this._listeners[type];
+    if (!list) { return; }
+    for (var i = 0; i < list.length; i++) {
+      if (list[i].callback === callback && list[i].capture === capture) {
+        list.splice(i, 1);
+        return;
+      }
+    }
+  };
+  EventTargetImpl.prototype.dispatchEvent = function (event) {
+    event.target = this;
+    event.currentTarget = this;
+    var list = this._listeners[event.type];
+    if (list) {
+      // Snapshot so listeners added during dispatch are not invoked and
+      // registration order is preserved.
+      var snapshot = list.slice();
+      for (var i = 0; i < snapshot.length; i++) {
+        var entry = snapshot[i];
+        var idx = list.indexOf(entry);
+        if (idx === -1) { continue; }  // removed since snapshot
+        if (entry.once) { list.splice(idx, 1); }
+        var cb = entry.callback;
+        try {
+          if (typeof cb === "function") {
+            cb.call(this, event);
+          } else if (cb && typeof cb.handleEvent === "function") {
+            cb.handleEvent(event);
+          }
+        } catch (e) {
+          reportListenerError(e);
+        }
+        if (event._stopImmediate) { break; }
+      }
+    }
+    event.currentTarget = null;
+    return !event.defaultPrevented;
+  };
+
+  // Internal EventTarget instance backing the global. globalThis's prototype
+  // is intentionally NOT made an EventTarget; only the three methods are
+  // bound onto it.
+  var globalTarget = new EventTargetImpl();
+  // Called by the error-events layer to install the native listener-error
+  // reporter into this closure. One-shot: the backing target leaks to app
+  // code via event.target, so the hook removes itself after the install
+  // (which happens during runtime init, before any user code runs).
+  globalTarget._installListenerErrorReporter = function (fn) {
+    reportListenerError = fn;
+    delete globalTarget._installListenerErrorReporter;
+  };
+  g.addEventListener = function (type, callback, options) {
+    return globalTarget.addEventListener(type, callback, options);
+  };
+  g.removeEventListener = function (type, callback, options) {
+    return globalTarget.removeEventListener(type, callback, options);
+  };
+  g.dispatchEvent = function (event) {
+    return globalTarget.dispatchEvent(event);
+  };
+
+  function EventTarget() { EventTargetImpl.call(this); }
+  EventTarget.prototype.addEventListener = EventTargetImpl.prototype.addEventListener;
+  EventTarget.prototype.removeEventListener = EventTargetImpl.prototype.removeEventListener;
+  EventTarget.prototype.dispatchEvent = EventTargetImpl.prototype.dispatchEvent;
+
+  g.Event = Event;
+  g.EventTarget = EventTarget;
+
+  return globalTarget;
+})
diff --git a/NativeScript/runtime/js/inline-functions.js b/NativeScript/runtime/js/inline-functions.js
new file mode 100644
index 00000000..72a99b62
--- /dev/null
+++ b/NativeScript/runtime/js/inline-functions.js
@@ -0,0 +1,101 @@
+Object.assign(global, {
+    CGPointMake(x, y) {
+        return new CGPoint({ x, y });
+    },
+    CGRectMake(x, y, width, height) {
+        return new CGRect({ origin: { x, y }, size: { width, height } });
+    },
+    CGSizeMake(width, height) {
+        return new CGSize({ width, height });
+    },
+    UIEdgeInsetsMake(top, left, bottom, right) {
+        return new UIEdgeInsets({ top, left, bottom, right });
+    },
+    NSMakeRange(location, length) {
+        return new NSRange({ location, length });
+    },
+
+    __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    },
+    __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    },
+
+    ObjCClass() {
+        var protocols = Array.from(arguments);
+        return function (target) {
+            if (protocols.length > 0) {
+                target.ObjCProtocols = (target.ObjCProtocols && target.ObjCProtocols instanceof Array ? target.ObjCProtocols.concat(protocols) : protocols);
+            }
+        }
+    },
+    ObjCMethod() {
+        var name = arguments[0];
+        var hasName = (name !== undefined && typeof name === "string");
+        var returnType = (hasName ? arguments[1] : arguments[0]);
+
+        return function (target, propertyKey, descriptor) {
+            if (!target.constructor.ObjCExposedMethods) {
+                target.constructor.ObjCExposedMethods = {};
+            }
+            if (!target.constructor.ObjCExposedMethods[propertyKey]) {
+                target.constructor.ObjCExposedMethods[propertyKey] = {};
+            }
+            target.constructor.ObjCExposedMethods[propertyKey].returns = returnType || interop.types.void;
+
+            if (hasName && name !== propertyKey) {
+                target.constructor.ObjCExposedMethods[name] = target.constructor.ObjCExposedMethods[propertyKey];
+                delete target.constructor.ObjCExposedMethods[propertyKey];
+
+                target[name] = function () { 
+                    return this[propertyKey].apply(this, arguments);
+                }
+            }
+        }
+    },
+    ObjC() {
+        var args = Array.from(arguments);
+
+        return function (target, propertyKey, descriptor) {
+            if (propertyKey === undefined) {
+                return ObjCClass.apply(this, args)(target);
+            }
+
+            ObjCMethod.apply(this, args)(target, propertyKey, descriptor);
+        };
+    },
+    ObjCParam(type) {
+        return function (target, propertyKey, parameterIndex) {
+            if (!target.constructor.ObjCExposedMethods) {
+                target.constructor.ObjCExposedMethods = {};
+            }
+            if (!target.constructor.ObjCExposedMethods[propertyKey]) {
+                target.constructor.ObjCExposedMethods[propertyKey] = {};
+            }
+            var exposedMethod = target.constructor.ObjCExposedMethods[propertyKey];
+            if (!exposedMethod.params) {
+                exposedMethod.params = [];
+            }
+            exposedMethod.params[parameterIndex] = type || interop.types.void;
+        };
+    },
+
+});
+
+Object.defineProperty(global, "__tsEnum", {
+    writable: false,
+    enumerable: false,
+    configurable: false,
+    value: function(obj) {
+        var result = {};
+        for (var key of Object.keys(obj)) {
+            result[key] = obj[key];
+            result[obj[key]] = key;
+        }
+        return result;
+    }
+});
diff --git a/NativeScript/runtime/js/placeholder-module.js b/NativeScript/runtime/js/placeholder-module.js
new file mode 100644
index 00000000..199f6477
--- /dev/null
+++ b/NativeScript/runtime/js/placeholder-module.js
@@ -0,0 +1,23 @@
+// Completion value is a factory invoked by ModuleInternal::CreatePlaceholderModule
+// with the per-module error message. Every touch of the returned exports object
+// throws, so optional modules that are absent fail loudly only when actually used.
+(function createPlaceholder(errorMessage) {
+    const error = new Error(errorMessage);
+    return new Proxy({}, {
+        get: function (target, prop) {
+            throw error;
+        },
+        set: function (target, prop, value) {
+            throw error;
+        },
+        has: function (target, prop) {
+            return false;
+        },
+        ownKeys: function (target) {
+            return [];
+        },
+        getPrototypeOf: function (target) {
+            return null;
+        }
+    });
+})
diff --git a/NativeScript/runtime/js/promise-proxy.js b/NativeScript/runtime/js/promise-proxy.js
new file mode 100644
index 00000000..b88f0b73
--- /dev/null
+++ b/NativeScript/runtime/js/promise-proxy.js
@@ -0,0 +1,69 @@
+// Run a Promise's callbacks on the thread that created it, but only when
+// that thread is the runtime loop. A Promise created on a background
+// thread settles on whichever thread resolves it, because the background
+// run loop may be dormant and marshaling a resolution to it would hang.
+(function(isRuntimeRunloop) {
+    global.Promise = new Proxy(global.Promise, {
+        construct: function(target, args) {
+            let origFunc = args[0];
+            let runloop = CFRunLoopGetCurrent();
+            let originIsRuntimeLoop = isRuntimeRunloop();
+
+            let promise = new target(function(resolve, reject) {
+                function isFulfilled() {
+                    return !resolve;
+                }
+                function markFulfilled() {
+                    origFunc = null;
+                    resolve = null;
+                    reject = null;
+                }
+                origFunc(value => {
+                    if (isFulfilled()) {
+                        return;
+                    }
+                    const resolveCall = resolve.bind(this, value);
+                    if (!originIsRuntimeLoop || runloop === CFRunLoopGetCurrent()) {
+                        markFulfilled();
+                        resolveCall();
+                    } else {
+                        CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, resolveCall);
+                        CFRunLoopWakeUp(runloop);
+                        markFulfilled();
+                    }
+                }, reason => {
+                    if (isFulfilled()) {
+                        return;
+                    }
+                    const rejectCall = reject.bind(this, reason);
+                    if (!originIsRuntimeLoop || runloop === CFRunLoopGetCurrent()) {
+                        markFulfilled();
+                        rejectCall();
+                    } else {
+                        CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, rejectCall);
+                        CFRunLoopWakeUp(runloop);
+                        markFulfilled();
+                    }
+                });
+            });
+
+            return new Proxy(promise, {
+                get: function(target, name) {
+                    let orig = target[name];
+                    if (name === "then" || name === "catch" || name === "finally") {
+                        return orig.bind(target);
+                    }
+                    return typeof orig === 'function' ? function(x) {
+                        if (!originIsRuntimeLoop || runloop === CFRunLoopGetCurrent()) {
+                            orig.bind(target, x)();
+                            return target;
+                        }
+                        CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, orig.bind(target, x));
+                        CFRunLoopWakeUp(runloop);
+                        return target;
+                    } : orig;
+                }
+            });
+        }
+    });
+})
diff --git a/NativeScript/runtime/js/require-factory.js b/NativeScript/runtime/js/require-factory.js
new file mode 100644
index 00000000..af08aa5c
--- /dev/null
+++ b/NativeScript/runtime/js/require-factory.js
@@ -0,0 +1,10 @@
+(function() { 
+    function require_factory(requireInternal, dirName) { 
+        return function require(modulePath) { 
+            if(global.__pauseOnNextRequire) {  debugger; 
+global.__pauseOnNextRequire = false; }
+            return requireInternal(modulePath, dirName); 
+        } 
+    } 
+    return require_factory; 
+})()
diff --git a/NativeScript/runtime/js/smart-stringify.js b/NativeScript/runtime/js/smart-stringify.js
new file mode 100644
index 00000000..0ff7f09d
--- /dev/null
+++ b/NativeScript/runtime/js/smart-stringify.js
@@ -0,0 +1,19 @@
+(function () {
+    function smartStringify(object) {
+        const seen = [];
+        var replacer = function (key, value) {
+            if (value != null && typeof value == "object") {
+                if (seen.indexOf(value) >= 0) {
+                    if (key) {
+                        return "[Circular]";
+                    }
+                    return;
+                }
+                seen.push(value);
+            }
+            return value;
+        };
+        return JSON.stringify(object, replacer, 2);
+    }
+    return smartStringify;
+})();
diff --git a/NativeScript/runtime/js/ts-helpers.js b/NativeScript/runtime/js/ts-helpers.js
new file mode 100644
index 00000000..38d43820
--- /dev/null
+++ b/NativeScript/runtime/js/ts-helpers.js
@@ -0,0 +1,107 @@
+(() => {
+    var __originalExtends = global.__extends;
+    var __extends = (Child, Parent) => {
+        var extendingNativeClass = !!Parent.extend && (Parent.extend.toString().indexOf("[native code]") > -1);
+        if (!extendingNativeClass) {
+            __extends_ts(Child, Parent);
+            return;
+        }
+
+        if (Parent.__isPrototypeImplementationObject) {
+            throw new Error("Can not extend an already extended native object.");
+        }
+
+        function extend(thiz) {
+            var child = thiz.__proto__.__child;
+            if (!child.__extended) {
+                var parent = thiz.__proto__.__parent;
+                child.__extended = parent.extend(child.prototype, {
+                    name: child.name,
+                    protocols: child.ObjCProtocols || [],
+                    exposedMethods: child.ObjCExposedMethods || {}
+                });
+                child[Symbol.hasInstance] = function (instance) {
+                    return instance instanceof this.__extended;
+                }
+            }
+            return child.__extended;
+        }
+
+        Parent.call = function (thiz) {
+            var Extended = extend(thiz);
+            thiz.__container__ = true;
+            if (arguments.length > 1) {
+                thiz.__proto__ = new (Function.prototype.bind.apply(Extended, [null].concat(Array.prototype.slice.call(arguments, 1))));
+            } else {
+                thiz.__proto__ = new Extended()
+            }
+            return thiz.__proto__;
+        };
+
+        Parent.apply = function (thiz, args) {
+            var Extended = extend(thiz);
+            thiz.__container__ = true;
+            if (args && args.length > 0) {
+                thiz.__proto__ = new (Function.prototype.bind.apply(Extended, [null].concat(args)));
+            } else {
+                thiz.__proto__ = new Extended();
+            }
+            return thiz.__proto__;
+        };
+
+        __extends_ns(Child, Parent);
+        Child.__isPrototypeImplementationObject = true;
+        Child.__proto__ = Parent;
+        Child.prototype.__parent = Parent;
+        Child.prototype.__child = Child;
+
+        if (__originalExtends) {
+            __originalExtends(Child, Parent);
+        }
+    };
+
+    var __extends_ts = function (child, parent) {
+        extendStaticFunctions(child, parent);
+        assignPrototypeFromParentToChild(parent, child);
+    };
+
+    var __extends_ns = function (child, parent) {
+        if (!parent.extend) {
+            assignPropertiesFromParentToChild(parent, child);
+        }
+
+        assignPrototypeFromParentToChild(parent, child);
+    };
+
+    var extendStaticFunctions =
+        Object.setPrototypeOf
+        || (hasInternalProtoProperty() && function (child, parent) { child.__proto__ = parent; })
+        || assignPropertiesFromParentToChild;
+
+    function hasInternalProtoProperty() {
+        return { __proto__: [] } instanceof Array;
+    }
+
+    function assignPropertiesFromParentToChild(parent, child) {
+        for (var property in parent) {
+            if (parent.hasOwnProperty(property)) {
+                child[property] = parent[property];
+            }
+        }
+    }
+
+    function assignPrototypeFromParentToChild(parent, child) {
+        function __() {
+            this.constructor = child;
+        }
+
+        if (parent === null) {
+            child.prototype = Object.create(null);
+        } else {
+            __.prototype = parent.prototype;
+            child.prototype = new __();
+        }
+    }
+
+    Object.defineProperty(global, "__extends", { value: __extends, writable: false });
+})()
diff --git a/NativeScript/runtime/js/weak-ref.js b/NativeScript/runtime/js/weak-ref.js
new file mode 100644
index 00000000..01e9fe03
--- /dev/null
+++ b/NativeScript/runtime/js/weak-ref.js
@@ -0,0 +1,9 @@
+global.WeakRef.prototype.get = global.WeakRef.prototype.deref;
+global.WeakRef.prototype.__hasWarnedAboutClear = false;
+global.WeakRef.prototype.clear = () => {
+    if(global.WeakRef.prototype.__hasWarnedAboutClear) {
+        return;
+    }
+    global.WeakRef.prototype.__hasWarnedAboutClear = true;
+    console.warn('WeakRef.clear() is non-standard and has been deprecated. It does nothing and the call can be safely removed.');
+}
diff --git a/README.md b/README.md
index 4c65f0f6..d42db08f 100644
--- a/README.md
+++ b/README.md
@@ -43,6 +43,10 @@ Runtime initialization took 55ms
 
 If all tests pass, everything is good! At this point you can make changes to the runtime, add breakpoints and step through with the debugger. In the next section we'll see how to attach the runtime to an existing NativeScript application allowing us to debug runtime issues in actual apps.
 
+# Documentation
+
+Runtime feature documentation lives in the [docs](docs/README.md) folder — see [Error handling](docs/error-handling.md) for the global error events, native exception round-tripping and `interop.escapeException`.
+
 # Attaching the runtime to a NativeScript app
 
 In the existing app, we need to prepare the Xcode project using `ns prepare ios`. This will create a folder named `platforms/ios` and in there a `<appname>.xcworkspace` (or .xcodeproject but note the following...).
diff --git a/TestFixtures/TNSTestNativeCallbacks.h b/TestFixtures/TNSTestNativeCallbacks.h
index 0e30a4b7..c5fc3272 100644
--- a/TestFixtures/TNSTestNativeCallbacks.h
+++ b/TestFixtures/TNSTestNativeCallbacks.h
@@ -69,4 +69,27 @@
 - (void (^)())getBlock;
 - (void (^)())getBlockFromNative;
 
+// Invokes `block` inside @try/@catch and returns the caught NSException, or nil
+// when the block completes without raising. Used to observe native exceptions
+// escaping from JS through interop.escapeException.
++ (NSException*)invokeBlockCatchingException:(void (^)(void))block;
+
+// Convenience: returns the caught exception's reason, or nil when none was
+// raised.
++ (NSString*)invokeAndDescribeException:(void (^)(void))block;
+
+// Returns the JavaScript stack trace associated with `exception` via the
+// NSException(NativeScript) category, or nil when unavailable. The category
+// lives in the NativeScript framework (loaded in-process at runtime) but is not
+// linked by TestFixtures at compile time, so it is invoked via performSelector.
++ (NSString* _Nullable)jsStackTraceForException:(NSException* _Nullable)exception;
+
+// Reads a key from a dictionary natively (exercises the JS-backed
+// DictionaryAdapter's objectForKey boundary).
++ (id)dictionaryValueForKey:(NSDictionary*)dictionary key:(NSString*)key;
+
+// Reads a key path from an object natively via KVC (exercises a JS property
+// accessor boundary).
++ (id)objectValueForKey:(id)object key:(NSString*)key;
+
 @end
diff --git a/TestFixtures/TNSTestNativeCallbacks.m b/TestFixtures/TNSTestNativeCallbacks.m
index 6f674e8e..abd0a28d 100644
--- a/TestFixtures/TNSTestNativeCallbacks.m
+++ b/TestFixtures/TNSTestNativeCallbacks.m
@@ -8,331 +8,411 @@
 @implementation TNSTestNativeCallbacks
 
 + (void)inheritanceMethodCalls:(TNSDerivedInterface*)object {
-    [object baseMethod];
-    [object baseProtocolMethod2];
-    [object baseProtocolMethod2Optional];
-    [object baseProtocolMethod1];
-    [object baseProtocolMethod1Optional];
-    [object baseCategoryMethod];
-    [object baseCategoryProtocolMethod2];
-    [object baseCategoryProtocolMethod2Optional];
-    [object baseCategoryProtocolMethod1];
-    [object baseCategoryProtocolMethod1Optional];
-    [object derivedMethod];
-    [object derivedProtocolMethod2];
-    [object derivedProtocolMethod2Optional];
-    [object derivedProtocolMethod1];
-    [object derivedProtocolMethod1Optional];
-    [object derivedCategoryMethod];
-    [object derivedCategoryProtocolMethod2];
-    [object derivedCategoryProtocolMethod2Optional];
-    [object derivedCategoryProtocolMethod1];
-    [object derivedCategoryProtocolMethod1Optional];
+  [object baseMethod];
+  [object baseProtocolMethod2];
+  [object baseProtocolMethod2Optional];
+  [object baseProtocolMethod1];
+  [object baseProtocolMethod1Optional];
+  [object baseCategoryMethod];
+  [object baseCategoryProtocolMethod2];
+  [object baseCategoryProtocolMethod2Optional];
+  [object baseCategoryProtocolMethod1];
+  [object baseCategoryProtocolMethod1Optional];
+  [object derivedMethod];
+  [object derivedProtocolMethod2];
+  [object derivedProtocolMethod2Optional];
+  [object derivedProtocolMethod1];
+  [object derivedProtocolMethod1Optional];
+  [object derivedCategoryMethod];
+  [object derivedCategoryProtocolMethod2];
+  [object derivedCategoryProtocolMethod2Optional];
+  [object derivedCategoryProtocolMethod1];
+  [object derivedCategoryProtocolMethod1Optional];
 }
 
 + (void)inheritanceConstructorCalls:(Class)JSDerivedInterface {
-    NSAssert([[[JSDerivedInterface alloc] initBaseProtocolMethod1] isKindOfClass:JSDerivedInterface], @"initBaseProtocolMethod1 failed");
-    NSAssert([[[JSDerivedInterface alloc] initBaseProtocolMethod1Optional] isKindOfClass:JSDerivedInterface], @"initBaseProtocolMethod1Optional failed");
-    NSAssert([[[JSDerivedInterface alloc] initBaseProtocolMethod2] isKindOfClass:JSDerivedInterface], @"initBaseProtocolMethod2 failed");
-    NSAssert([[[JSDerivedInterface alloc] initBaseProtocolMethod2Optional] isKindOfClass:JSDerivedInterface], @"initBaseProtocolMethod2Optional failed");
-    NSAssert([[[JSDerivedInterface alloc] initBaseMethod] isKindOfClass:JSDerivedInterface], @"initBaseMethod failed");
-    NSAssert([[[JSDerivedInterface alloc] initBaseCategoryProtocolMethod1] isKindOfClass:JSDerivedInterface], @"initBaseCategoryProtocolMethod1 failed");
-    NSAssert([[[JSDerivedInterface alloc] initBaseCategoryProtocolMethod1Optional] isKindOfClass:JSDerivedInterface], @"initBaseCategoryProtocolMethod1Optional failed");
-    NSAssert([[[JSDerivedInterface alloc] initBaseCategoryProtocolMethod2] isKindOfClass:JSDerivedInterface], @"initBaseCategoryProtocolMethod2 failed");
-    NSAssert([[[JSDerivedInterface alloc] initBaseCategoryProtocolMethod2Optional] isKindOfClass:JSDerivedInterface], @"initBaseCategoryProtocolMethod2Optional failed");
-    NSAssert([[[JSDerivedInterface alloc] initBaseCategoryMethod] isKindOfClass:JSDerivedInterface], @"initBaseCategoryMethod failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedProtocolMethod1] isKindOfClass:JSDerivedInterface], @"initDerivedProtocolMethod1 failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedProtocolMethod1Optional] isKindOfClass:JSDerivedInterface], @"initDerivedProtocolMethod1Optional failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedProtocolMethod2] isKindOfClass:JSDerivedInterface], @"initDerivedProtocolMethod2 failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedProtocolMethod2Optional] isKindOfClass:JSDerivedInterface], @"initDerivedProtocolMethod2Optional failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedMethod] isKindOfClass:JSDerivedInterface], @"initDerivedMethod failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedCategoryProtocolMethod1] isKindOfClass:JSDerivedInterface], @"initDerivedCategoryProtocolMethod1 failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedCategoryProtocolMethod1Optional] isKindOfClass:JSDerivedInterface], @"initDerivedCategoryProtocolMethod1Optional failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedCategoryProtocolMethod2] isKindOfClass:JSDerivedInterface], @"initDerivedCategoryProtocolMethod2 failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedCategoryProtocolMethod2Optional] isKindOfClass:JSDerivedInterface], @"initDerivedCategoryProtocolMethod2Optional failed");
-    NSAssert([[[JSDerivedInterface alloc] initDerivedCategoryMethod] isKindOfClass:JSDerivedInterface], @"initDerivedCategoryMethod failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseProtocolMethod1] isKindOfClass:JSDerivedInterface],
+           @"initBaseProtocolMethod1 failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseProtocolMethod1Optional]
+               isKindOfClass:JSDerivedInterface],
+           @"initBaseProtocolMethod1Optional failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseProtocolMethod2] isKindOfClass:JSDerivedInterface],
+           @"initBaseProtocolMethod2 failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseProtocolMethod2Optional]
+               isKindOfClass:JSDerivedInterface],
+           @"initBaseProtocolMethod2Optional failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseMethod] isKindOfClass:JSDerivedInterface],
+           @"initBaseMethod failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseCategoryProtocolMethod1]
+               isKindOfClass:JSDerivedInterface],
+           @"initBaseCategoryProtocolMethod1 failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseCategoryProtocolMethod1Optional]
+               isKindOfClass:JSDerivedInterface],
+           @"initBaseCategoryProtocolMethod1Optional failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseCategoryProtocolMethod2]
+               isKindOfClass:JSDerivedInterface],
+           @"initBaseCategoryProtocolMethod2 failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseCategoryProtocolMethod2Optional]
+               isKindOfClass:JSDerivedInterface],
+           @"initBaseCategoryProtocolMethod2Optional failed");
+  NSAssert([[[JSDerivedInterface alloc] initBaseCategoryMethod] isKindOfClass:JSDerivedInterface],
+           @"initBaseCategoryMethod failed");
+  NSAssert(
+      [[[JSDerivedInterface alloc] initDerivedProtocolMethod1] isKindOfClass:JSDerivedInterface],
+      @"initDerivedProtocolMethod1 failed");
+  NSAssert([[[JSDerivedInterface alloc] initDerivedProtocolMethod1Optional]
+               isKindOfClass:JSDerivedInterface],
+           @"initDerivedProtocolMethod1Optional failed");
+  NSAssert(
+      [[[JSDerivedInterface alloc] initDerivedProtocolMethod2] isKindOfClass:JSDerivedInterface],
+      @"initDerivedProtocolMethod2 failed");
+  NSAssert([[[JSDerivedInterface alloc] initDerivedProtocolMethod2Optional]
+               isKindOfClass:JSDerivedInterface],
+           @"initDerivedProtocolMethod2Optional failed");
+  NSAssert([[[JSDerivedInterface alloc] initDerivedMethod] isKindOfClass:JSDerivedInterface],
+           @"initDerivedMethod failed");
+  NSAssert([[[JSDerivedInterface alloc] initDerivedCategoryProtocolMethod1]
+               isKindOfClass:JSDerivedInterface],
+           @"initDerivedCategoryProtocolMethod1 failed");
+  NSAssert([[[JSDerivedInterface alloc] initDerivedCategoryProtocolMethod1Optional]
+               isKindOfClass:JSDerivedInterface],
+           @"initDerivedCategoryProtocolMethod1Optional failed");
+  NSAssert([[[JSDerivedInterface alloc] initDerivedCategoryProtocolMethod2]
+               isKindOfClass:JSDerivedInterface],
+           @"initDerivedCategoryProtocolMethod2 failed");
+  NSAssert([[[JSDerivedInterface alloc] initDerivedCategoryProtocolMethod2Optional]
+               isKindOfClass:JSDerivedInterface],
+           @"initDerivedCategoryProtocolMethod2Optional failed");
+  NSAssert(
+      [[[JSDerivedInterface alloc] initDerivedCategoryMethod] isKindOfClass:JSDerivedInterface],
+      @"initDerivedCategoryMethod failed");
 }
 
 + (void)inheritancePropertyCalls:(TNSDerivedInterface*)object {
-    object.baseProtocolProperty1 = 0;
-    UNUSED(object.baseProtocolProperty1);
-    object.baseProtocolProperty1Optional = 0;
-    UNUSED(object.baseProtocolProperty1Optional);
-    object.baseProtocolProperty2 = 0;
-    UNUSED(object.baseProtocolProperty2);
-    object.baseProtocolProperty2Optional = 0;
-    UNUSED(object.baseProtocolProperty2Optional);
-    object.baseProperty = 0;
-    UNUSED(object.baseProperty);
-    object.baseCategoryProtocolProperty1 = 0;
-    UNUSED(object.baseCategoryProtocolProperty1);
-    object.baseCategoryProtocolProperty1Optional = 0;
-    UNUSED(object.baseCategoryProtocolProperty1Optional);
-    object.baseCategoryProtocolProperty2 = 0;
-    UNUSED(object.baseCategoryProtocolProperty2);
-    object.baseCategoryProtocolProperty2Optional = 0;
-    UNUSED(object.baseCategoryProtocolProperty2Optional);
-    object.baseCategoryProperty = 0;
-    UNUSED(object.baseCategoryProperty);
-    object.derivedProtocolProperty1 = 0;
-    UNUSED(object.derivedProtocolProperty1);
-    object.derivedProtocolProperty1Optional = 0;
-    UNUSED(object.derivedProtocolProperty1Optional);
-    object.derivedProtocolProperty2 = 0;
-    UNUSED(object.derivedProtocolProperty2);
-    object.derivedProtocolProperty2Optional = 0;
-    UNUSED(object.derivedProtocolProperty2Optional);
-    object.derivedProperty = 0;
-    UNUSED(object.derivedProperty);
-    object.derivedCategoryProtocolProperty1 = 0;
-    UNUSED(object.derivedCategoryProtocolProperty1);
-    object.derivedCategoryProtocolProperty1Optional = 0;
-    UNUSED(object.derivedCategoryProtocolProperty1Optional);
-    object.derivedCategoryProtocolProperty2 = 0;
-    UNUSED(object.derivedCategoryProtocolProperty2);
-    object.derivedCategoryProtocolProperty2Optional = 0;
-    UNUSED(object.derivedCategoryProtocolProperty2Optional);
-    object.derivedCategoryProperty = 0;
-    UNUSED(object.derivedCategoryProperty);
+  object.baseProtocolProperty1 = 0;
+  UNUSED(object.baseProtocolProperty1);
+  object.baseProtocolProperty1Optional = 0;
+  UNUSED(object.baseProtocolProperty1Optional);
+  object.baseProtocolProperty2 = 0;
+  UNUSED(object.baseProtocolProperty2);
+  object.baseProtocolProperty2Optional = 0;
+  UNUSED(object.baseProtocolProperty2Optional);
+  object.baseProperty = 0;
+  UNUSED(object.baseProperty);
+  object.baseCategoryProtocolProperty1 = 0;
+  UNUSED(object.baseCategoryProtocolProperty1);
+  object.baseCategoryProtocolProperty1Optional = 0;
+  UNUSED(object.baseCategoryProtocolProperty1Optional);
+  object.baseCategoryProtocolProperty2 = 0;
+  UNUSED(object.baseCategoryProtocolProperty2);
+  object.baseCategoryProtocolProperty2Optional = 0;
+  UNUSED(object.baseCategoryProtocolProperty2Optional);
+  object.baseCategoryProperty = 0;
+  UNUSED(object.baseCategoryProperty);
+  object.derivedProtocolProperty1 = 0;
+  UNUSED(object.derivedProtocolProperty1);
+  object.derivedProtocolProperty1Optional = 0;
+  UNUSED(object.derivedProtocolProperty1Optional);
+  object.derivedProtocolProperty2 = 0;
+  UNUSED(object.derivedProtocolProperty2);
+  object.derivedProtocolProperty2Optional = 0;
+  UNUSED(object.derivedProtocolProperty2Optional);
+  object.derivedProperty = 0;
+  UNUSED(object.derivedProperty);
+  object.derivedCategoryProtocolProperty1 = 0;
+  UNUSED(object.derivedCategoryProtocolProperty1);
+  object.derivedCategoryProtocolProperty1Optional = 0;
+  UNUSED(object.derivedCategoryProtocolProperty1Optional);
+  object.derivedCategoryProtocolProperty2 = 0;
+  UNUSED(object.derivedCategoryProtocolProperty2);
+  object.derivedCategoryProtocolProperty2Optional = 0;
+  UNUSED(object.derivedCategoryProtocolProperty2Optional);
+  object.derivedCategoryProperty = 0;
+  UNUSED(object.derivedCategoryProperty);
 }
 
 + (void)inheritanceVoidSelector:(id)object {
-    SEL sel = NSSelectorFromString(@"voidSelector");
-    NSAssert([object respondsToSelector:sel], @"Object does not respond to selector");
-    ((void (*)(id, SEL))objc_msgSend)(object, sel);
+  SEL sel = NSSelectorFromString(@"voidSelector");
+  NSAssert([object respondsToSelector:sel], @"Object does not respond to selector");
+  ((void (*)(id, SEL))objc_msgSend)(object, sel);
 }
 
 + (id)inheritanceVariadicSelector:(id)object {
-    SEL sel = NSSelectorFromString(@"variadicSelector:x:");
-    NSAssert([object respondsToSelector:sel], @"Object does not respond to selector");
-    id result = ((id(*)(id, SEL, NSString*, int))objc_msgSend)(object, sel, @"native", 9);
-    return result;
+  SEL sel = NSSelectorFromString(@"variadicSelector:x:");
+  NSAssert([object respondsToSelector:sel], @"Object does not respond to selector");
+  id result = ((id (*)(id, SEL, NSString*, int))objc_msgSend)(object, sel, @"native", 9);
+  return result;
 }
 
 + (void)inheritanceOptionalProtocolMethodsAndCategories:(TNSIDerivedInterface*)object {
-    BOOL responds;
+  BOOL responds;
 
-    // Base
-    [object baseImplementedOptionalMethod];
+  // Base
+  [object baseImplementedOptionalMethod];
 
-    responds = [object respondsToSelector:@selector(baseNotImplementedOptionalMethod)];
-    NSAssert(!responds, NSStringFromSelector(_cmd));
+  responds = [object respondsToSelector:@selector(baseNotImplementedOptionalMethod)];
+  NSAssert(!responds, NSStringFromSelector(_cmd));
 
-    [object baseNotImplementedOptionalMethodImplementedInJavaScript];
+  [object baseNotImplementedOptionalMethodImplementedInJavaScript];
 
-    [object baseImplementedCategoryMethod];
+  [object baseImplementedCategoryMethod];
 
-    responds = [object respondsToSelector:@selector(baseNotImplementedCategoryMethod)];
-    NSAssert(!responds, NSStringFromSelector(_cmd));
+  responds = [object respondsToSelector:@selector(baseNotImplementedCategoryMethod)];
+  NSAssert(!responds, NSStringFromSelector(_cmd));
 
-    [object baseNotImplementedNativeCategoryMethodOverridenInJavaScript];
+  [object baseNotImplementedNativeCategoryMethodOverridenInJavaScript];
 
-    // Derived
-    [object derivedImplementedOptionalMethod];
+  // Derived
+  [object derivedImplementedOptionalMethod];
 
-    responds = [object respondsToSelector:@selector(derivedNotImplementedOptionalMethod)];
-    NSAssert(!responds, NSStringFromSelector(_cmd));
+  responds = [object respondsToSelector:@selector(derivedNotImplementedOptionalMethod)];
+  NSAssert(!responds, NSStringFromSelector(_cmd));
 
-    [object derivedNotImplementedOptionalMethodImplementedInJavaScript];
+  [object derivedNotImplementedOptionalMethodImplementedInJavaScript];
 
-    [object derivedImplementedCategoryMethod];
+  [object derivedImplementedCategoryMethod];
 
-    responds = [object respondsToSelector:@selector(derivedNotImplementedCategoryMethod)];
-    NSAssert(!responds, NSStringFromSelector(_cmd));
+  responds = [object respondsToSelector:@selector(derivedNotImplementedCategoryMethod)];
+  NSAssert(!responds, NSStringFromSelector(_cmd));
 
-    [object derivedNotImplementedNativeCategoryMethodOverridenInJavaScript];
+  [object derivedNotImplementedNativeCategoryMethodOverridenInJavaScript];
 }
 
 + (void)apiCustomGetterAndSetter:(TNSApi*)object {
-    NSAssert(object.property == 3, NSStringFromSelector(_cmd));
+  NSAssert(object.property == 3, NSStringFromSelector(_cmd));
 }
 
 + (void)apiOverrideWithCustomGetterAndSetter:(TNSApi*)object {
-    NSAssert(object.property == -6, NSStringFromSelector(_cmd));
+  NSAssert(object.property == -6, NSStringFromSelector(_cmd));
 }
 
 + (void)apiReadonlyPropertyInProtocolAndOverrideWithSetterInInterface:(UIView*)object {
-    NSAssert(CGRectEqualToRect([object bounds], CGRectMake(10, 20, 30, 40)), NSStringFromSelector(_cmd));
+  NSAssert(CGRectEqualToRect([object bounds], CGRectMake(10, 20, 30, 40)),
+           NSStringFromSelector(_cmd));
 }
 
 + (void)apiDescriptionOverride:(id)object {
-    NSAssert([[object description] isEqualToString:@"js description"], NSStringFromSelector(_cmd));
+  NSAssert([[object description] isEqualToString:@"js description"], NSStringFromSelector(_cmd));
 }
 
 + (void)apiNSErrorOverride:(TNSApi*)object {
-    {
-        NSError* error = nil;
-        NSAssert([object method:0 error:&error] == false, NSStringFromSelector(_cmd));
-        NSAssert(error == nil, NSStringFromSelector(_cmd));
-    }
+  {
+    NSError* error = nil;
+    NSAssert([object method:0 error:&error] == false, NSStringFromSelector(_cmd));
+    NSAssert(error == nil, NSStringFromSelector(_cmd));
+  }
 
-    NSAssert([object method:1 error:nil] == false, NSStringFromSelector(_cmd));
+  NSAssert([object method:1 error:nil] == false, NSStringFromSelector(_cmd));
 
-    {
-        NSError* error = nil;
-        NSAssert([object method:1 error:&error] == false, NSStringFromSelector(_cmd));
-        TNSLog(error.domain);
-    }
+  {
+    NSError* error = nil;
+    NSAssert([object method:1 error:&error] == false, NSStringFromSelector(_cmd));
+    TNSLog(error.domain);
+  }
 }
 
 + (void)apiNSErrorExpose:(TNSApi*)object {
-    {
-        NSError* error = nil;
-        NSAssert(((BOOL(*)(id, SEL, int, NSError**))objc_msgSend)(object, NSSelectorFromString(@"method:error2:"), 0, &error) == true, NSStringFromSelector(_cmd));
-        NSAssert(error == nil, NSStringFromSelector(_cmd));
-    }
-
-    NSAssert(((BOOL(*)(id, SEL, int, NSError**))objc_msgSend)(object, NSSelectorFromString(@"method:error2:"), 1, nil) == false, NSStringFromSelector(_cmd));
-
-    {
-        NSError* error = nil;
-        NSAssert(((BOOL(*)(id, SEL, int, NSError**))objc_msgSend)(object, NSSelectorFromString(@"method:error2:"), 1, &error) == false, NSStringFromSelector(_cmd));
-        TNSLog(error.domain);
-    }
+  {
+    NSError* error = nil;
+    NSAssert(((BOOL (*)(id, SEL, int, NSError**))objc_msgSend)(
+                 object, NSSelectorFromString(@"method:error2:"), 0, &error) == true,
+             NSStringFromSelector(_cmd));
+    NSAssert(error == nil, NSStringFromSelector(_cmd));
+  }
+
+  NSAssert(((BOOL (*)(id, SEL, int, NSError**))objc_msgSend)(
+               object, NSSelectorFromString(@"method:error2:"), 1, nil) == false,
+           NSStringFromSelector(_cmd));
+
+  {
+    NSError* error = nil;
+    NSAssert(((BOOL (*)(id, SEL, int, NSError**))objc_msgSend)(
+                 object, NSSelectorFromString(@"method:error2:"), 1, &error) == false,
+             NSStringFromSelector(_cmd));
+    TNSLog(error.domain);
+  }
 }
 
 + (void)protocolImplementationMethods:(id<TNSBaseProtocol1, NSObject>)object {
-    NSAssert([object conformsToProtocol:@protocol(TNSBaseProtocol1)], NSStringFromSelector(_cmd));
-    NSAssert([[object class] conformsToProtocol:@protocol(TNSBaseProtocol1)], NSStringFromSelector(_cmd));
-    [object baseProtocolMethod1];
+  NSAssert([object conformsToProtocol:@protocol(TNSBaseProtocol1)], NSStringFromSelector(_cmd));
+  NSAssert([[object class] conformsToProtocol:@protocol(TNSBaseProtocol1)],
+           NSStringFromSelector(_cmd));
+  [object baseProtocolMethod1];
 }
 
 + (void)categoryProtocolImplementationMethods:(id<TNSBaseCategoryProtocol1, NSObject>)object {
-    NSAssert([object conformsToProtocol:@protocol(TNSBaseCategoryProtocol1)], NSStringFromSelector(_cmd));
-    NSAssert([[object class] conformsToProtocol:@protocol(TNSBaseCategoryProtocol1)], NSStringFromSelector(_cmd));
-    [object baseCategoryProtocolMethod1];
+  NSAssert([object conformsToProtocol:@protocol(TNSBaseCategoryProtocol1)],
+           NSStringFromSelector(_cmd));
+  NSAssert([[object class] conformsToProtocol:@protocol(TNSBaseCategoryProtocol1)],
+           NSStringFromSelector(_cmd));
+  [object baseCategoryProtocolMethod1];
 }
 
 + (void)protocolImplementationProtocolInheritance:(id<TNSBaseProtocol2, NSObject>)object {
-    NSAssert([object conformsToProtocol:@protocol(TNSBaseProtocol1)], NSStringFromSelector(_cmd));
-    NSAssert([[object class] conformsToProtocol:@protocol(TNSBaseProtocol1)], NSStringFromSelector(_cmd));
-    [object baseProtocolMethod1];
+  NSAssert([object conformsToProtocol:@protocol(TNSBaseProtocol1)], NSStringFromSelector(_cmd));
+  NSAssert([[object class] conformsToProtocol:@protocol(TNSBaseProtocol1)],
+           NSStringFromSelector(_cmd));
+  [object baseProtocolMethod1];
 
-    NSAssert([object conformsToProtocol:@protocol(TNSBaseProtocol2)], NSStringFromSelector(_cmd));
-    NSAssert([[object class] conformsToProtocol:@protocol(TNSBaseProtocol2)], NSStringFromSelector(_cmd));
-    [object baseProtocolMethod2];
+  NSAssert([object conformsToProtocol:@protocol(TNSBaseProtocol2)], NSStringFromSelector(_cmd));
+  NSAssert([[object class] conformsToProtocol:@protocol(TNSBaseProtocol2)],
+           NSStringFromSelector(_cmd));
+  [object baseProtocolMethod2];
 }
 
 + (void)protocolImplementationOptionalMethods:(id<TNSBaseProtocol2, NSObject>)object {
-    BOOL responds;
+  BOOL responds;
 
-    responds = [object respondsToSelector:@selector(baseProtocolMethod1Optional)];
-    NSAssert(responds, NSStringFromSelector(_cmd));
-    [object baseProtocolMethod1Optional];
+  responds = [object respondsToSelector:@selector(baseProtocolMethod1Optional)];
+  NSAssert(responds, NSStringFromSelector(_cmd));
+  [object baseProtocolMethod1Optional];
 
-    responds = [object respondsToSelector:@selector(baseProtocolMethod2Optional)];
-    NSAssert(!responds, NSStringFromSelector(_cmd));
+  responds = [object respondsToSelector:@selector(baseProtocolMethod2Optional)];
+  NSAssert(!responds, NSStringFromSelector(_cmd));
 }
 
 + (void)protocolImplementationProperties:(id<TNSBaseProtocol1, NSObject>)object {
-    object.baseProtocolProperty1 = 0;
-    UNUSED(object.baseProtocolProperty1);
-    object.baseProtocolProperty1Optional = 0;
-    UNUSED(object.baseProtocolProperty1Optional);
+  object.baseProtocolProperty1 = 0;
+  UNUSED(object.baseProtocolProperty1);
+  object.baseProtocolProperty1Optional = 0;
+  UNUSED(object.baseProtocolProperty1Optional);
 }
 
 + (BOOL)protocolWithNameConflict:(id<TNSPropertyMethodConflictProtocol, NSObject>)object {
-    return object.conflict;
+  return object.conflict;
 }
 
 + (TNSSimpleStruct)recordsSimpleStruct:(TNSSimpleStruct)object {
-    TNSLog([NSString stringWithFormat:@"%d %d", object.x, object.y]);
-    return object;
+  TNSLog([NSString stringWithFormat:@"%d %d", object.x, object.y]);
+  return object;
 }
 
 + (TNSStruct16)recordsStruct16:(TNSStruct16)object {
-    TNSLog([NSString stringWithFormat:@"%lld %d %d", object.x, object.y, object.z]);
-    return object;
+  TNSLog([NSString stringWithFormat:@"%lld %d %d", object.x, object.y, object.z]);
+  return object;
 }
 
 + (TNSStruct24)recordsStruct24:(TNSStruct24)object {
-    TNSLog([NSString stringWithFormat:@"%lld %d %lld", object.x, object.y, object.z]);
-    return object;
+  TNSLog([NSString stringWithFormat:@"%lld %d %lld", object.x, object.y, object.z]);
+  return object;
 }
 
 + (TNSStruct32)recordsStruct32:(TNSStruct32)object {
-    TNSLog([NSString stringWithFormat:@"%lld %lld %lld", object.x, object.y, object.z]);
-    return object;
+  TNSLog([NSString stringWithFormat:@"%lld %lld %lld", object.x, object.y, object.z]);
+  return object;
 }
 
 + (TNSNestedStruct)recordsNestedStruct:(TNSNestedStruct)object {
-    TNSLog([NSString stringWithFormat:@"%d %d %d %d", object.a.x, object.a.y, object.b.x, object.b.y]);
-    return object;
+  TNSLog(
+      [NSString stringWithFormat:@"%d %d %d %d", object.a.x, object.a.y, object.b.x, object.b.y]);
+  return object;
 }
 
 + (TNSStructWithArray)recordsStructWithArray:(TNSStructWithArray)object {
-    TNSLog([NSString stringWithFormat:@"%d %d %d %d %d", object.x, object.arr[0], object.arr[1], object.arr[2], object.arr[3]]);
-    return object;
+  TNSLog([NSString stringWithFormat:@"%d %d %d %d %d", object.x, object.arr[0], object.arr[1],
+                                    object.arr[2], object.arr[3]]);
+  return object;
 }
 
 + (TNSNestedAnonymousStruct)recordsNestedAnonymousStruct:(TNSNestedAnonymousStruct)object {
-    TNSLog([NSString stringWithFormat:@"%d %d %d", object.x1, object.y1.x2, object.y1.y2.x3]);
-    return object;
+  TNSLog([NSString stringWithFormat:@"%d %d %d", object.x1, object.y1.x2, object.y1.y2.x3]);
+  return object;
 }
 
 + (TNSComplexStruct)recordsComplexStruct:(TNSComplexStruct)object {
-    TNSLog([NSString stringWithFormat:@"%d %d %d %d %d %d %d",
-                                      object.x1,
-                                      object.y1[0].x2,
-                                      object.y1[0].y2.x3[0],
-                                      object.y1[0].y2.x3[1],
-                                      object.y1[1].x2,
-                                      object.y1[1].y2.x3[0],
-                                      object.y1[1].y2.x3[1]]);
-    return object;
+  TNSLog([NSString stringWithFormat:@"%d %d %d %d %d %d %d", object.x1, object.y1[0].x2,
+                                    object.y1[0].y2.x3[0], object.y1[0].y2.x3[1], object.y1[1].x2,
+                                    object.y1[1].y2.x3[0], object.y1[1].y2.x3[1]]);
+  return object;
 }
 
 + (void)recordsPointer:(TNSSimpleStruct*)object {
-    TNSLog([NSString stringWithFormat:@"%d %d", object->x, object->y]);
+  TNSLog([NSString stringWithFormat:@"%d %d", object->x, object->y]);
 }
 
 + (void)apiNSMutableArrayMethods:(NSMutableArray*)object {
-    [object addObject:@"b"];
-    [object addObject:@"x"];
-    [object addObject:@"c"];
-    [object addObject:@"y"];
-    [object addObject:@"z"];
-    [object insertObject:@"a" atIndex:0];
-    [object removeObjectAtIndex:2];
-    [object removeLastObject];
-    object[3] = @"d";
-    TNSLog([NSString stringWithFormat:@"%tu%tu", [object count], [object hash]]);
-
-    for (id x in object) {
-        TNSLog([NSString stringWithFormat:@"%@", x]);
-    }
+  [object addObject:@"b"];
+  [object addObject:@"x"];
+  [object addObject:@"c"];
+  [object addObject:@"y"];
+  [object addObject:@"z"];
+  [object insertObject:@"a" atIndex:0];
+  [object removeObjectAtIndex:2];
+  [object removeLastObject];
+  object[3] = @"d";
+  TNSLog([NSString stringWithFormat:@"%tu%tu", [object count], [object hash]]);
+
+  for (id x in object) {
+    TNSLog([NSString stringWithFormat:@"%@", x]);
+  }
 }
 
 + (void)apiSwizzle:(TNSSwizzleKlass*)object {
-    object.aProperty = 3;
-    TNSLog([NSString stringWithFormat:@"%d", object.aProperty]);
-    TNSLog([NSString stringWithFormat:@"%d", [[object class] staticMethod:3]]);
-    TNSLog([NSString stringWithFormat:@"%d", [object instanceMethod:3]]);
+  object.aProperty = 3;
+  TNSLog([NSString stringWithFormat:@"%d", object.aProperty]);
+  TNSLog([NSString stringWithFormat:@"%d", [[object class] staticMethod:3]]);
+  TNSLog([NSString stringWithFormat:@"%d", [object instanceMethod:3]]);
 }
 
 + (NSString*)callRecursively:(NSString* (^)())block {
-    return block();
+  return block();
 }
 
 + (NSString*)callOnThread:(NSString* (^)())block {
-    NSString* __block result = nil;
+  NSString* __block result = nil;
 
-    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
-    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-      result = block();
-      dispatch_semaphore_signal(semaphore);
-    });
-    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+  dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    result = block();
+    dispatch_semaphore_signal(semaphore);
+  });
+  dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
 
-    return result;
+  return result;
 }
 
 - (void (^)())getBlock {
-    return nil;
+  return nil;
 }
 
 - (void (^)())getBlockFromNative {
-    return [self getBlock];
+  return [self getBlock];
+}
+
++ (NSException*)invokeBlockCatchingException:(void (^)(void))block {
+  @try {
+    block();
+  } @catch (NSException* e) {
+    return e;
+  }
+  return nil;
+}
+
++ (NSString*)invokeAndDescribeException:(void (^)(void))block {
+  NSException* e = [self invokeBlockCatchingException:block];
+  return e ? e.reason : nil;
+}
+
++ (NSString*)jsStackTraceForException:(NSException*)exception {
+  if (exception == nil) {
+    return nil;
+  }
+  SEL sel = NSSelectorFromString(@"tns_javascriptStackTrace");
+  if (![exception respondsToSelector:sel]) {
+    return nil;
+  }
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+  return [exception performSelector:sel];
+#pragma clang diagnostic pop
+}
+
++ (id)dictionaryValueForKey:(NSDictionary*)dictionary key:(NSString*)key {
+  return [dictionary objectForKey:key];
+}
+
++ (id)objectValueForKey:(id)object key:(NSString*)key {
+  return [object valueForKey:key];
 }
 
 @end
diff --git a/TestRunner/app/tests/ErrorEventsTests.js b/TestRunner/app/tests/ErrorEventsTests.js
new file mode 100644
index 00000000..fa515774
--- /dev/null
+++ b/TestRunner/app/tests/ErrorEventsTests.js
@@ -0,0 +1,291 @@
+describe("WHATWG error events", function () {
+    // Many tests exercise the global error/rejection path, which ends in the
+    // __onUncaughtError shim when a listener does not preventDefault(). Install a
+    // spy for every test and restore the previous hook in afterEach. Also track
+    // listeners added on the global target so they never leak into other suites
+    // (the internal EventTarget backing the global is process-wide).
+    let previousHook;
+    let uncaught;
+    let addedGlobalListeners;
+
+    beforeEach(function () {
+        previousHook = global.__onUncaughtError;
+        uncaught = [];
+        global.__onUncaughtError = function (error) {
+            uncaught.push(error);
+        };
+        addedGlobalListeners = [];
+    });
+
+    afterEach(function () {
+        global.__onUncaughtError = previousHook;
+        for (let i = 0; i < addedGlobalListeners.length; i++) {
+            const l = addedGlobalListeners[i];
+            global.removeEventListener(l.type, l.handler);
+        }
+        addedGlobalListeners = [];
+    });
+
+    function onGlobal(type, handler) {
+        global.addEventListener(type, handler);
+        addedGlobalListeners.push({ type: type, handler: handler });
+    }
+
+    // Poll across a few runloop turns until `predicate` is true (or give up).
+    function pollUntil(predicate, cb) {
+        let turns = 0;
+        (function poll() {
+            if (predicate() || turns >= 25) {
+                cb();
+                return;
+            }
+            turns++;
+            setTimeout(poll, 10);
+        })();
+    }
+
+    // Wait a couple of quiet runloop turns before asserting a NON-event.
+    function afterQuietTurns(cb) {
+        setTimeout(function () {
+            setTimeout(cb, 25);
+        }, 25);
+    }
+
+    it("reportError fires an 'error' listener with an ErrorEvent carrying error and message", function (done) {
+        const err = new Error("x");
+        let received = null;
+        onGlobal("error", function (e) {
+            received = e;
+            e.preventDefault();
+        });
+
+        global.reportError(err);
+
+        expect(received).not.toBeNull();
+        expect(received instanceof ErrorEvent).toBe(true);
+        expect(received.type).toBe("error");
+        expect(received.error).toBe(err);
+        expect(received.message).toBe("x");
+        // preventDefault() in the listener must suppress the __onUncaughtError shim.
+        afterQuietTurns(function () {
+            expect(uncaught.length).toBe(0);
+            done();
+        });
+    });
+
+    it("reportError without preventDefault still invokes __onUncaughtError (back-compat)", function (done) {
+        const err = new Error("back-compat");
+        let received = null;
+        onGlobal("error", function (e) {
+            received = e;
+        });
+
+        global.reportError(err);
+
+        expect(received).not.toBeNull();
+        expect(received.error).toBe(err);
+        expect(uncaught.length).toBe(1);
+        expect(uncaught[0]).toBe(err);
+        done();
+    });
+
+    it("reportError throws TypeError when called with no arguments", function () {
+        expect(function () {
+            global.reportError();
+        }).toThrowError(TypeError);
+    });
+
+    it("unhandledrejection listener receives reason and promise; preventDefault suppresses the shim", function (done) {
+        const reason = new Error("rejected");
+        let received = null;
+        onGlobal("unhandledrejection", function (e) {
+            received = e;
+            e.preventDefault();
+        });
+
+        Promise.reject(reason);
+
+        pollUntil(function () { return received !== null; }, function () {
+            expect(received).not.toBeNull();
+            expect(received instanceof PromiseRejectionEvent).toBe(true);
+            expect(received.type).toBe("unhandledrejection");
+            expect(received.reason).toBe(reason);
+            expect(typeof received.promise.then).toBe("function");
+            afterQuietTurns(function () {
+                expect(uncaught.length).toBe(0);
+                done();
+            });
+        });
+    });
+
+    it("an unhandled rejection with no listener still reaches __onUncaughtError", function (done) {
+        const reason = new Error("no-listener-rejection");
+        Promise.reject(reason);
+
+        pollUntil(function () { return uncaught.length > 0; }, function () {
+            expect(uncaught.length).toBeGreaterThan(0);
+            expect(uncaught[0]).toBe(reason);
+            done();
+        });
+    });
+
+    it("fires rejectionhandled when a handler is attached after the rejection was reported", function (done) {
+        const reason = new Error("late-handler");
+        let rejectionHandled = null;
+        onGlobal("rejectionhandled", function (e) {
+            rejectionHandled = e;
+        });
+        // Prevent the report so it does not hit the shim; the promise still counts
+        // as reported and becomes outstanding for rejectionhandled purposes.
+        // Capture the promise carried by the unhandledrejection event: the runtime
+        // events carry the underlying V8 promise (the PromiseProxy wrapper the
+        // user holds is a different object), so "same promise" is verified by
+        // comparing the two events' promise, which must be identical.
+        let reportedPromise = null;
+        onGlobal("unhandledrejection", function (e) {
+            reportedPromise = e.promise;
+            e.preventDefault();
+        });
+
+        const p = Promise.reject(reason);
+
+        pollUntil(function () { return reportedPromise !== null; }, function () {
+            // Attach a late handler a couple turns after the report.
+            setTimeout(function () {
+                p.catch(function () {});
+                pollUntil(function () { return rejectionHandled !== null; }, function () {
+                    expect(rejectionHandled).not.toBeNull();
+                    expect(rejectionHandled instanceof PromiseRejectionEvent).toBe(true);
+                    expect(rejectionHandled.type).toBe("rejectionhandled");
+                    expect(typeof rejectionHandled.promise.then).toBe("function");
+                    expect(rejectionHandled.promise).toBe(reportedPromise);
+                    // The original rejection reason is retained past reporting
+                    // and carried on the rejectionhandled event, per spec.
+                    expect(rejectionHandled.reason).toBe(reason);
+                    done();
+                });
+            }, 20);
+        });
+    });
+
+    describe("constructors and EventTarget semantics", function () {
+        it("Event is spec-sane and cancelable via preventDefault", function () {
+            const e = new Event("x", { cancelable: true });
+            expect(e.type).toBe("x");
+            expect(e.cancelable).toBe(true);
+            expect(e.bubbles).toBe(false);
+            expect(e.defaultPrevented).toBe(false);
+            e.preventDefault();
+            expect(e.defaultPrevented).toBe(true);
+        });
+
+        it("a non-cancelable Event ignores preventDefault", function () {
+            const e = new Event("x");
+            e.preventDefault();
+            expect(e.defaultPrevented).toBe(false);
+        });
+
+        it("ErrorEvent exposes message/error/filename/lineno/colno", function () {
+            const err = new Error("boom");
+            const e = new ErrorEvent("error", { message: "m", error: err });
+            expect(e instanceof Event).toBe(true);
+            expect(e.message).toBe("m");
+            expect(e.error).toBe(err);
+            expect(e.filename).toBe("");
+            expect(e.lineno).toBe(0);
+            expect(e.colno).toBe(0);
+        });
+
+        it("PromiseRejectionEvent exposes promise/reason", function () {
+            const p = Promise.reject(1);
+            p.catch(function () {});
+            const r = { some: "reason" };
+            const e = new PromiseRejectionEvent("unhandledrejection", { promise: p, reason: r });
+            expect(e instanceof Event).toBe(true);
+            expect(e.promise).toBe(p);
+            expect(e.reason).toBe(r);
+        });
+
+        it("dispatchEvent returns !defaultPrevented", function () {
+            const target = new EventTarget();
+            target.addEventListener("t", function (e) { e.preventDefault(); });
+            expect(target.dispatchEvent(new Event("t", { cancelable: true }))).toBe(false);
+
+            const target2 = new EventTarget();
+            target2.addEventListener("t", function () {});
+            expect(target2.dispatchEvent(new Event("t", { cancelable: true }))).toBe(true);
+        });
+
+        it("once:true listener fires exactly once", function () {
+            const target = new EventTarget();
+            let count = 0;
+            target.addEventListener("t", function () { count++; }, { once: true });
+            target.dispatchEvent(new Event("t"));
+            target.dispatchEvent(new Event("t"));
+            expect(count).toBe(1);
+        });
+
+        it("removeEventListener stops future dispatches", function () {
+            const target = new EventTarget();
+            let count = 0;
+            const handler = function () { count++; };
+            target.addEventListener("t", handler);
+            target.dispatchEvent(new Event("t"));
+            target.removeEventListener("t", handler);
+            target.dispatchEvent(new Event("t"));
+            expect(count).toBe(1);
+        });
+
+        it("listeners run in registration order", function () {
+            const target = new EventTarget();
+            const order = [];
+            target.addEventListener("t", function () { order.push(1); });
+            target.addEventListener("t", function () { order.push(2); });
+            target.addEventListener("t", function () { order.push(3); });
+            target.dispatchEvent(new Event("t"));
+            expect(order).toEqual([1, 2, 3]);
+        });
+
+        it("stopImmediatePropagation stops remaining listeners", function () {
+            const target = new EventTarget();
+            const order = [];
+            target.addEventListener("t", function (e) { order.push(1); e.stopImmediatePropagation(); });
+            target.addEventListener("t", function () { order.push(2); });
+            target.dispatchEvent(new Event("t"));
+            expect(order).toEqual([1]);
+        });
+
+        it("a throwing listener does not stop later listeners", function () {
+            const target = new EventTarget();
+            const order = [];
+            target.addEventListener("t", function () { order.push(1); throw new Error("listener boom"); });
+            target.addEventListener("t", function () { order.push(2); });
+            target.dispatchEvent(new Event("t"));
+            expect(order).toEqual([1, 2]);
+        });
+    });
+
+    it("reportError still fires listeners after globalThis.dispatchEvent is overwritten", function (done) {
+        const err = new Error("resilient");
+        let received = null;
+        onGlobal("error", function (e) {
+            received = e;
+            e.preventDefault();
+        });
+
+        const originalDispatch = globalThis.dispatchEvent;
+        globalThis.dispatchEvent = function () { return true; };
+        try {
+            global.reportError(err);
+        } finally {
+            globalThis.dispatchEvent = originalDispatch;
+        }
+
+        expect(received).not.toBeNull();
+        expect(received.error).toBe(err);
+        afterQuietTurns(function () {
+            expect(uncaught.length).toBe(0);
+            done();
+        });
+    });
+});
diff --git a/TestRunner/app/tests/EscapeExceptionTests.js b/TestRunner/app/tests/EscapeExceptionTests.js
new file mode 100644
index 00000000..dccaee59
--- /dev/null
+++ b/TestRunner/app/tests/EscapeExceptionTests.js
@@ -0,0 +1,260 @@
+describe("interop.escapeException and boundary hardening", function () {
+    // Several tests drive an unhandled/reported error through the uncaught path,
+    // which ends in the __onUncaughtError shim (unless a listener prevents it).
+    // Spy on it and restore the previous hook afterwards.
+    let previousHook;
+    let uncaught;
+
+    beforeEach(function () {
+        previousHook = global.__onUncaughtError;
+        uncaught = [];
+        global.__onUncaughtError = function (error) {
+            uncaught.push(error);
+        };
+    });
+
+    afterEach(function () {
+        global.__onUncaughtError = previousHook;
+    });
+
+    function uncaughtSeen(substr) {
+        for (let i = 0; i < uncaught.length; i++) {
+            const e = uncaught[i];
+            const msg = e && e.message !== undefined ? String(e.message) : String(e);
+            if (msg.indexOf(substr) > -1) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function pollUntil(predicate, cb) {
+        let turns = 0;
+        (function poll() {
+            if (predicate() || turns >= 25) {
+                cb();
+                return;
+            }
+            turns++;
+            setTimeout(poll, 10);
+        })();
+    }
+
+    describe("interop.escapeException()", function () {
+        it("returns a throwable Error preserving the message", function () {
+            const wrapped = interop.escapeException(new Error("boom"));
+            expect(wrapped instanceof Error).toBe(true);
+            expect(wrapped.message).toBe("boom");
+
+            let caught = null;
+            try {
+                throw wrapped;
+            } catch (e) {
+                caught = e;
+            }
+            expect(caught).toBe(wrapped);
+        });
+
+        it("throws TypeError when called with no arguments", function () {
+            expect(function () {
+                interop.escapeException();
+            }).toThrowError(TypeError);
+        });
+
+        it("is idempotent (double-wrap returns the same object)", function () {
+            const once = interop.escapeException(new Error("once"));
+            const twice = interop.escapeException(once);
+            expect(twice).toBe(once);
+        });
+    });
+
+    describe("escaping through a native-invoked block", function () {
+        it("a branded escape surfaces to native as an NSException; JS keeps running", function () {
+            const ex = TNSTestNativeCallbacks.invokeBlockCatchingException(function () {
+                throw interop.escapeException(new Error("escape-me"));
+            });
+
+            expect(ex).not.toBeNull();
+            expect(ex instanceof NSException).toBe(true);
+            expect(ex.reason).toContain("escape-me");
+
+            // JS is still alive after the escape round-trip.
+            expect(1 + 1).toBe(2);
+        });
+
+        it("a plain Error is not escaped as an NSException; it surfaces as a normal JS throw", function () {
+            // The whole chain is JS-initiated, so an unbranded plain error thrown
+            // in the block propagates back to this JS caller (correct exception
+            // semantics) rather than becoming an ObjC NSException — and it does
+            // not abort the process.
+            let caught = null;
+            let ret;
+            try {
+                ret = TNSTestNativeCallbacks.invokeBlockCatchingException(function () {
+                    throw new Error("plain-no-escape");
+                });
+            } catch (e) {
+                caught = e;
+            }
+
+            expect(caught).not.toBeNull();
+            expect(caught.message).toBe("plain-no-escape");
+            expect(caught instanceof NSException).toBe(false);
+            // The fixture never caught an NSException, so it never returned one.
+            expect(ret).toBeUndefined();
+        });
+
+        it("round-trips an original native NSException back to native", function () {
+            let caughtInJs = null;
+            try {
+                NSArray.alloc().init().objectAtIndex(3);
+            } catch (e) {
+                caughtInJs = e;
+            }
+            expect(caughtInJs).not.toBeNull();
+            expect(caughtInJs.nativeException instanceof NSException).toBe(true);
+
+            const ex = TNSTestNativeCallbacks.invokeBlockCatchingException(function () {
+                throw interop.escapeException(caughtInJs);
+            });
+
+            expect(ex).not.toBeNull();
+            expect(ex instanceof NSException).toBe(true);
+            expect(ex.name).toBe("NSRangeException");
+            expect(ex.reason).toContain("beyond bounds");
+        });
+    });
+
+    describe("JS stack travels with escaped exceptions", function () {
+        // Named functions so the captured JS stack contains recognizable tokens
+        // regardless of how the module's script name is rendered in a frame.
+        function escapeSiteMarker(makeThrow) {
+            makeThrow();
+        }
+
+        it("a synthesized escape carries the JS stack in userInfo and via the category", function () {
+            const ex = TNSTestNativeCallbacks.invokeBlockCatchingException(function () {
+                escapeSiteMarker(function throwSynthesizedEscape() {
+                    throw interop.escapeException(new Error("synth-with-stack"));
+                });
+            });
+
+            expect(ex).not.toBeNull();
+            expect(ex instanceof NSException).toBe(true);
+
+            // userInfo carries the origin JS stack under the documented key.
+            const userInfoStack = ex.userInfo ? ex.userInfo.objectForKey("JavaScriptStack") : null;
+            expect(userInfoStack).not.toBeNull();
+            expect(String(userInfoStack)).toContain("throwSynthesizedEscape");
+
+            // The category (associated-object) accessor returns the same/similar text.
+            const viaCategory = TNSTestNativeCallbacks.jsStackTraceForException(ex);
+            expect(viaCategory).not.toBeNull();
+            expect(String(viaCategory)).toContain("throwSynthesizedEscape");
+        });
+
+        it("a non-Error escape still produces an escape-site stack via the category", function () {
+            const ex = TNSTestNativeCallbacks.invokeBlockCatchingException(function () {
+                escapeSiteMarker(function throwPlainStringEscape() {
+                    throw interop.escapeException("plain-string");
+                });
+            });
+
+            expect(ex).not.toBeNull();
+            expect(ex instanceof NSException).toBe(true);
+
+            const viaCategory = TNSTestNativeCallbacks.jsStackTraceForException(ex);
+            expect(viaCategory).not.toBeNull();
+            expect(String(viaCategory).length).toBeGreaterThan(0);
+            expect(String(viaCategory)).toContain("throwPlainStringEscape");
+        });
+
+        it("an original native NSException round-trips unchanged but carries a JS stack via the category", function () {
+            let caughtInJs = null;
+            try {
+                NSArray.alloc().init().objectAtIndex(3);
+            } catch (e) {
+                caughtInJs = e;
+            }
+            expect(caughtInJs).not.toBeNull();
+            expect(caughtInJs.nativeException instanceof NSException).toBe(true);
+
+            const ex = TNSTestNativeCallbacks.invokeBlockCatchingException(function () {
+                escapeSiteMarker(function rethrowOriginalNativeException() {
+                    throw interop.escapeException(caughtInJs);
+                });
+            });
+
+            // The original native exception reaches native unchanged.
+            expect(ex).not.toBeNull();
+            expect(ex instanceof NSException).toBe(true);
+            expect(ex.name).toBe("NSRangeException");
+            expect(ex.reason).toContain("beyond bounds");
+
+            // Identity preserved: no JavaScriptStack key was injected into userInfo.
+            const userInfoStack = ex.userInfo ? ex.userInfo.objectForKey("JavaScriptStack") : null;
+            expect(userInfoStack).toBeNull();
+
+            // ...but the associated-object stack is now available via the category,
+            // proving attachment without mutating the exception.
+            const viaCategory = TNSTestNativeCallbacks.jsStackTraceForException(ex);
+            expect(viaCategory).not.toBeNull();
+            expect(String(viaCategory).length).toBeGreaterThan(0);
+            expect(String(viaCategory)).toContain("rethrowOriginalNativeException");
+        });
+    });
+
+    describe("adapter boundary hardening (no process abort on JS throw)", function () {
+        it("a throwing getter read through the DictionaryAdapter yields a default, reports, and does not crash", function (done) {
+            const jsObject = {
+                get boom() {
+                    throw new Error("dict-adapter-boom");
+                }
+            };
+
+            const value = TNSTestNativeCallbacks.dictionaryValueForKeyKey(jsObject, "boom");
+            // Native received a default (nil) instead of the process aborting.
+            expect(value).toBeNull();
+
+            pollUntil(function () { return uncaughtSeen("dict-adapter-boom"); }, function () {
+                expect(uncaughtSeen("dict-adapter-boom")).toBe(true);
+                done();
+            });
+        });
+
+        it("a throwing overridden property getter read from native does not crash and is reported", function (done) {
+            // baseProperty uses the default getter selector (KVC-accessible),
+            // unlike TNSApi.property which has a custom getter.
+            const Derived = TNSDerivedInterface.extend({
+                get baseProperty() {
+                    throw new Error("getter-adapter-boom");
+                }
+            });
+            const instance = Derived.alloc().init();
+
+            // Reading the overridden getter from native must not abort the process
+            // and must not propagate (the hardened ClassBuilder accessor reports
+            // the unbranded error and returns a default value).
+            let threw = false;
+            try {
+                TNSTestNativeCallbacks.objectValueForKeyKey(instance, "baseProperty");
+            } catch (e) {
+                threw = true;
+            }
+            expect(threw).toBe(false);
+
+            pollUntil(function () { return uncaughtSeen("getter-adapter-boom"); }, function () {
+                expect(uncaughtSeen("getter-adapter-boom")).toBe(true);
+                done();
+            });
+        });
+    });
+
+    // manual: crashOnUncaughtJsExceptions is not exercised automatically because a
+    // real crash would kill the test runner. To smoke it manually, set
+    // { "crashOnUncaughtJsExceptions": true } in the app config and throw an
+    // unprevented error (or `throw interop.escapeException(err)` from an `error`
+    // listener) — the app must terminate with a NativeScriptFatalJSException
+    // crash report scheduled on the runtime loop. Default-off behavior (report +
+    // continue) is covered by every other suite here.
+});
diff --git a/TestRunner/app/tests/MethodCallsTests.js b/TestRunner/app/tests/MethodCallsTests.js
index 6da28679..e5f24f40 100644
--- a/TestRunner/app/tests/MethodCallsTests.js
+++ b/TestRunner/app/tests/MethodCallsTests.js
@@ -1103,36 +1103,24 @@ describe(module.id, function () {
         expect(actual).toBe('static setDerivedCategoryProperty: calledstatic derivedCategoryProperty called');
     });
 
-    if (isSimulator) {
-    //     // Skip on simulator because libffi breaks exception unwinding on iOS Simulator
-    //     // see https://github.com/libffi/libffi/issues/418
-    //     console.warn("warning: Skipping ObjC exceptions tests on Simulator device!");
-    // } else {
-    //     it('Throw_ObjC_exceptions_to_JavaScript', function () {
-    //         try {
-    //             NSArray.alloc().init().objectAtIndex(3);
-    //             expect(false).toBeTruthy("Should never be reached because objectAtIndex(3) should throw an Objective-C exception.");
-    //         } catch(e) {
-    //             expect(e.stack).toContain("app/MethodCallsTests.js")
-    //             expect(e.nativeException).toBeDefined();
-    //             expect(e.nativeException instanceof NSException).toBe(true);
-    //             expect(e.nativeException.toString()).toBe(e.nativeException.reason);
-    //             expect(e.nativeException.reason).toContain("index 3 beyond bounds");
-    //             expect(e.nativeException.name).toBe("NSRangeException");
-    //             expect(e.nativeException.callStackSymbols.count).toBeGreaterThan(5);
-
-    //             var nativeCallstack = "";
-    //             for (var i=0; i < e.nativeException.callStackSymbols.count; i++) {
-    //                 nativeCallstack += e.nativeException.callStackSymbols[i] + '\n';
-    //             }
-
-    //             expect(nativeCallstack).toContain("CoreFoundation");
-    //             expect(nativeCallstack).toContain("TestRunner");
-    //             expect(nativeCallstack).toContain("objc_exception_throw");
-    //             expect(nativeCallstack).toContain("UIApplicationMain");
-    //         }
-    //     });
-    }
+    // Runs on both simulator and device: libffi 3.7.1 (this branch's libffi
+    // update) fixed ObjC exception unwinding through ffi_call on the arm64
+    // simulator, so the former isSimulator skip is obsolete.
+    it('Throw_ObjC_exceptions_to_JavaScript', function () {
+        try {
+            NSArray.alloc().init().objectAtIndex(3);
+            expect(false).toBeTruthy("Should never be reached because objectAtIndex(3) should throw an Objective-C exception.");
+        } catch(e) {
+            expect(e.nativeException).toBeDefined();
+            expect(e.nativeException instanceof NSException).toBe(true);
+            expect(e.nativeException.reason).toContain("beyond bounds");
+            expect(e.nativeException.name).toBe("NSRangeException");
+
+            // The callstack-content assertions below are environmental (symbol
+            // names differ across simulator/device); keep only a loose count check.
+            expect(e.nativeException.callStackSymbols.count).toBeGreaterThan(0);
+        }
+    });
 
      it('Override: More than one methods with same jsname', function () {
 
diff --git a/TestRunner/app/tests/Promises.js b/TestRunner/app/tests/Promises.js
index 4d4f38cd..7c681f1e 100644
--- a/TestRunner/app/tests/Promises.js
+++ b/TestRunner/app/tests/Promises.js
@@ -151,3 +151,103 @@ describe("Promise scheduling", function () {
         });
     });
 });
+
+describe("unhandled rejections", function () {
+    // Unhandled rejections are tracked per-isolate and reported once per runloop
+    // turn (kCFRunLoopBeforeWaiting) through the same uncaught-error machinery
+    // exposed via global.__onUncaughtError. Each test installs a temporary hook
+    // and restores the previous one in afterEach no matter what.
+    let previousHook;
+    let reported;
+
+    beforeEach(function () {
+        previousHook = global.__onUncaughtError;
+        reported = [];
+        global.__onUncaughtError = function (error) {
+            reported.push(error);
+        };
+    });
+
+    afterEach(function () {
+        global.__onUncaughtError = previousHook;
+    });
+
+    // The drain happens on a runloop turn, so poll across a few turns until the
+    // hook fires (or give up after a bounded number of turns).
+    function afterDrain(cb) {
+        let turns = 0;
+        (function poll() {
+            if (reported.length > 0 || turns >= 20) {
+                cb();
+                return;
+            }
+            turns++;
+            setTimeout(poll, 10);
+        })();
+    }
+
+    // Wait a couple of runloop turns to confirm the hook did NOT fire.
+    function afterQuietTurns(cb) {
+        setTimeout(function () {
+            setTimeout(cb, 20);
+        }, 20);
+    }
+
+    it("reports an unhandled Promise.reject", function (done) {
+        const reason = new Error("unhandled-promise-reject");
+        Promise.reject(reason);
+        afterDrain(function () {
+            expect(reported.length).toBeGreaterThan(0);
+            expect(reported[0]).toBe(reason);
+            done();
+        });
+    });
+
+    it("does not report when .catch is attached synchronously in the same turn", function (done) {
+        const p = Promise.reject(new Error("handled-same-turn"));
+        p.catch(function () {});
+        afterQuietTurns(function () {
+            expect(reported.length).toBe(0);
+            done();
+        });
+    });
+
+    it("reports an uncaught throw from an async function", function (done) {
+        const reason = new Error("async-function-throw");
+        (async () => {
+            throw reason;
+        })();
+        afterDrain(function () {
+            expect(reported.length).toBeGreaterThan(0);
+            expect(reported[0]).toBe(reason);
+            done();
+        });
+    });
+
+    it("reports an unhandled rejection thrown from a .then callback", function (done) {
+        const reason = new Error("then-callback-throw");
+        Promise.resolve().then(() => {
+            throw reason;
+        });
+        afterDrain(function () {
+            expect(reported.length).toBeGreaterThan(0);
+            expect(reported[0]).toBe(reason);
+            done();
+        });
+    });
+
+    it("ignores a late .catch attached after the rejection was already reported", function (done) {
+        const reason = new Error("late-catch");
+        const p = Promise.reject(reason);
+        afterDrain(function () {
+            expect(reported.length).toBeGreaterThan(0);
+            // Attaching a handler after the report was already delivered must not
+            // crash (Phase 1 silently drops the already-drained entry).
+            p.catch(function () {});
+            afterQuietTurns(function () {
+                expect(reported.length).toBe(1);
+                done();
+            });
+        });
+    });
+});
diff --git a/TestRunner/app/tests/index.js b/TestRunner/app/tests/index.js
index d8971960..009f4297 100644
--- a/TestRunner/app/tests/index.js
+++ b/TestRunner/app/tests/index.js
@@ -95,6 +95,12 @@ require("./NodeBuiltinsAndOptionalModulesTests.mjs");
 // Exception handling tests
 require("./ExceptionHandlingTests");
 
+// WHATWG error events (error/unhandledrejection/rejectionhandled, reportError)
+require("./ErrorEventsTests");
+
+// interop.escapeException + JS<->native boundary hardening (Phase 3)
+require("./EscapeExceptionTests");
+
 // Tests common for all runtimes (git submodule of NativeScript/common-runtime-tests-app).
 require("../shared/index").runAllTests();
 
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 00000000..2cba01a0
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,3 @@
+# Runtime documentation
+
+- [Error handling](error-handling.md) — global `error`/`unhandledrejection` events, `reportError`, catching native exceptions in JS (`error.nativeException`), forwarding JS throws to native (`interop.escapeException`), JS stacks on `NSException`, configuration flags, and crash-reporter integration.
diff --git a/docs/error-handling.md b/docs/error-handling.md
new file mode 100644
index 00000000..87f2b523
--- /dev/null
+++ b/docs/error-handling.md
@@ -0,0 +1,207 @@
+# Error handling
+
+The runtime implements the WHATWG error model at the global level: uncaught JavaScript exceptions and unhandled promise rejections are dispatched as cancelable events on `globalThis`, native `NSException`s round-trip into JavaScript with the original object attached, and `interop.escapeException` forwards a JavaScript throw to a native caller as a real `@throw`. By default nothing crashes the app — reporting is opt-out per error (`preventDefault()`), and crashing is opt-in (`crashOnUncaughtJsExceptions`).
+
+## Quick reference
+
+| Situation | Default behavior |
+|---|---|
+| Uncaught JS exception | Cancelable `error` event on `globalThis` → if unprevented: `__onUncaughtError` hook, fatal log, error modal in debug. App keeps running. |
+| Unhandled promise rejection | Tracked per isolate, reported once per run-loop turn: cancelable `unhandledrejection` event → same fallback chain, prefixed `Unhandled promise rejection:`. |
+| `.catch()` added after the report | `rejectionhandled` event (non-cancelable), carrying the original reason. |
+| JS throw inside a native callback (overridden method, block, property accessor, adapter) | Reported through the same pipeline; the native caller receives a zero/`nil` default and continues. The process never aborts on a JS throw. |
+| `throw interop.escapeException(x)` inside a native callback | Converted to a real native `@throw` at the boundary — no JS-side reporting; the native caller's `@try/@catch` sees the exception. |
+| Native `@throw` during a JS→native call | Surfaced to JS as an `Error` carrying the original exception as `error.nativeException`. |
+
+## JavaScript API
+
+### Global error events
+
+```js
+globalThis.addEventListener("error", (e) => {
+  // e is an ErrorEvent: { message, error, filename, lineno, colno }
+  // (filename/lineno/colno are not populated yet)
+  console.log(e.message, e.error);
+  e.preventDefault(); // marks the error handled: no hook, no fatal log, no modal
+});
+
+globalThis.addEventListener("unhandledrejection", (e) => {
+  // e is a PromiseRejectionEvent: { promise, reason }
+  console.log(e.reason);
+  e.preventDefault();
+});
+
+globalThis.addEventListener("rejectionhandled", (e) => {
+  // fired (as a task, on the next run-loop turn) when a handler is attached
+  // to a promise whose rejection was already reported; carries the original
+  // reason. Not cancelable.
+});
+```
+
+Notes:
+
+- `error` and `unhandledrejection` are `cancelable`; `preventDefault()` suppresses every downstream consequence (legacy hooks, fatal log, error modal, `crashOnUncaughtJsExceptions`).
+- Events fire even if app code overwrites `globalThis.dispatchEvent` — native dispatch goes through closures captured at startup.
+- A listener that throws does not stop the remaining listeners; the thrown value is routed to the fatal reporting tail directly (never recursively dispatched as another `error` event).
+- The events also fire on worker globals. A worker's unhandled rejection dispatches `unhandledrejection` on the worker's own global first; only when unprevented does it continue to the worker-global `onerror` and then to the main isolate's `worker.onerror`, mirroring uncaught worker errors.
+
+### `reportError`
+
+Routes a caught-but-fatal error through the exact same pipeline as an uncaught exception:
+
+```js
+reportError(new Error("something unrecoverable"));
+```
+
+### Event classes
+
+`Event`, `EventTarget`, `ErrorEvent` and `PromiseRejectionEvent` are installed as global constructors. `Event`/`EventTarget` are general-purpose (registration order, `once`/`capture` options, `stopImmediatePropagation`, `handleEvent` objects) and usable for your own eventing:
+
+```js
+const target = new EventTarget();
+target.addEventListener("tick", (e) => { ... }, { once: true });
+target.dispatchEvent(new Event("tick")); // returns !defaultPrevented
+```
+
+### What lands on the events
+
+The stacks live on the error/reason **value**, not on the event — and the thrown value can be anything, so shape-check before use:
+
+| You wrote | `e.error` / `e.reason` is | JS stack | Native exception |
+|---|---|---|---|
+| `throw new Error("x")` | that `Error` | `e.error.stack` | — |
+| called a native method that threw, without try/catch | an `Error` with `name` = the `NSException` name, `message` = its reason | `e.error.stack` (the JS call site) | `e.error.nativeException` — the original `NSException` (`.name`, `.reason`, `.userInfo`, `.callStackSymbols` captured at the native throw) |
+| `throw NSException.exceptionWithNameReasonUserInfo(...)` | the wrapped `NSException` itself — not an `Error`, no `.stack` | — | `e.error` directly (`instanceof NSException`); `.callStackSymbols` is only populated if it was actually thrown natively, not when merely constructed |
+
+### Catching native exceptions
+
+```js
+try {
+  NSArray.alloc().init().objectAtIndex(3);
+} catch (e) {
+  e.nativeException instanceof NSException; // true
+  e.nativeException.name;                   // "NSRangeException"
+  e.nativeException.reason;                 // "... index 3 beyond bounds ..."
+  e.nativeException.callStackSymbols;       // native frames at the throw site
+}
+```
+
+Methods with `NSError**` out-parameters are unchanged: they throw a JS `Error` with `code`, `domain` and `nativeException` set to the `NSError`.
+
+### Forwarding a throw to native: `interop.escapeException`
+
+A plain JS throw inside a native callback is reported and the native caller continues with a default value. When the native caller *must* observe the failure — a parent `@try/@catch` is waiting, or you want a real native crash — brand the throw:
+
+```js
+const Delegate = NSObject.extend({
+  someNativeMethod() {
+    throw interop.escapeException(new Error("propagate me natively"));
+  },
+}, { protocols: [SomeProtocol] });
+```
+
+At the JS→native boundary the branded throw becomes a native `@throw` (executed only after every V8 scope has unwound). Semantics:
+
+- `escapeException(err)` returns a JS `Error` (message/stack copied), so it behaves like a normal throw in pure-JS paths; the brand is an isolate-private symbol that user code cannot forge. Passing an already-branded value is a no-op; calling with no argument throws `TypeError`.
+- If `err` is (or carries via `.nativeException`) a native `NSException`, the **original object** is rethrown — a parent `@catch (NSRangeException *)` matches, and identity is preserved:
+
+```js
+try {
+  riskyNativeCall();
+} catch (e) {
+  throw interop.escapeException(e); // rethrows the exact original NSException
+}
+```
+
+- Otherwise an `NSException` is synthesized: `name` from the error's name, `reason` from its message plus the JS stack, and the stacks in `userInfo` (see the native section).
+- An escaped exception that nothing catches natively terminates the app with a real native crash report.
+- Escapes thrown from *inside* an `error`/`unhandledrejection` listener are honored too: the reporting tail detects the brand and schedules the native throw.
+
+Limitations: two boundaries execute under the *caller's* live V8 scopes and therefore cannot convert a branded escape into a native throw — fast enumeration (`for...in` over a JS object from native) and `DictionaryAdapter.getProperties`. There, a branded escape surfaces as an ordinary JS exception.
+
+## Native API
+
+### Catching escaped exceptions
+
+```objc
+@try {
+  [jsImplementedObject someNativeMethod];
+} @catch (NSException *e) {
+  // For synthesized escapes: e.name/e.reason come from the JS error, and
+  // e.reason includes the JS stack. For rethrown originals: e is the very
+  // same object that was originally thrown natively.
+}
+```
+
+### JS stack traces on `NSException`
+
+Every `NSException` produced by the escape/crash machinery carries the JavaScript context:
+
+```objc
+#import <NativeScript/NSExceptionSupport.h>
+
+NSString *jsStack = exception.tns_javascriptStackTrace; // nil when no JS involvement
+```
+
+The accessor is uniform across all cases; underneath:
+
+| Exception | Where the JS stack lives |
+|---|---|
+| Synthesized escape | `userInfo[TNSJavaScriptStackTraceKey]` (`@"JavaScriptStack"`), plus `userInfo[TNSJavaScriptEscapeStackTraceKey]` (`@"JavaScriptEscapeStack"`) when the `escapeException` call site differs from the error's origin; also appended to `reason` |
+| Rethrown original `NSException` | attached as an associated object (identity and `userInfo` are untouched); the string combines the origin stack and the escape site |
+| `crashOnUncaughtJsExceptions` fatal (`NativeScriptFatalJSException`) | `userInfo[TNSJavaScriptStackTraceKey]`, also in `reason` |
+
+`tns_javascriptStackTrace` and the two `userInfo` keys are the stable contract for crash-SDK integrations.
+
+## Configuration
+
+Both flags live in the app's `package.json`, both default to off:
+
+| Flag | Effect |
+|---|---|
+| `discardUncaughtJsExceptions` | Unprevented errors call `__onDiscardedError` instead of `__onUncaughtError` and skip the fatal log. Also disables `crashOnUncaughtJsExceptions`. |
+| `crashOnUncaughtJsExceptions` | After an unprevented error is reported, the app crashes with a real `NSException` (JS stack in `reason` and `userInfo`), thrown from a clean frame on the runtime loop so crash reporters capture it properly. |
+
+Terminal-path decision table for an uncaught error / unhandled rejection:
+
+| Condition | legacy hook called | fatal log / modal | native crash |
+|---|---|---|---|
+| default | `__onUncaughtError` | yes | no |
+| `discardUncaughtJsExceptions` | `__onDiscardedError` | no | no |
+| listener called `preventDefault()` | no | no | no |
+| `crashOnUncaughtJsExceptions`, unprevented | `__onUncaughtError` | yes | yes |
+
+## Crash reporter integration
+
+JS side — attach both the JS and native exception from one listener:
+
+```js
+function nativeExceptionOf(value) {
+  if (value instanceof NSException) return value;
+  return (value && value.nativeException instanceof NSException) ? value.nativeException : null;
+}
+
+globalThis.addEventListener("error", (e) => {
+  const err = e.error;
+  const native = nativeExceptionOf(err);
+  crashReporter.capture(err instanceof Error ? err : new Error(e.message), {
+    nativeName: native?.name,
+    nativeReason: native?.reason,
+    nativeStack: native?.callStackSymbols, // NSArray of symbolicated frames
+  });
+  // e.preventDefault(); // only if the reporter fully owns error handling
+});
+```
+
+Native side — for the `NSUncaughtExceptionHandler`/signal layer, read `exception.tns_javascriptStackTrace` (or the `userInfo` keys) to attach the JS stack to crashes that never pass through the JS event layer (escaped exceptions, `crashOnUncaughtJsExceptions`).
+
+## Legacy hooks (deprecated)
+
+`global.__onUncaughtError` and `global.__onDiscardedError` keep working exactly as before and are what `@nativescript/core` currently installs (surfaced as `Application.uncaughtErrorEvent` / `discardedErrorEvent`). They are invoked only when no event listener called `preventDefault()`. New code should prefer `globalThis.addEventListener("error" | "unhandledrejection", ...)`.
+
+## Behavior details
+
+- Every error is reported exactly once: either the V8 message listener (synchronous throws), the rejection drain (once per run-loop turn, `kCFRunLoopBeforeWaiting`), or the boundary handler — never two of them for the same error.
+- A rejection that gets a handler before the end-of-turn drain is never reported (and produces no `rejectionhandled` either).
+- Rejection events carry the underlying V8 promise. `Promise.reject(...)` returns a `PromiseProxy`-wrapped object, so compare promises between events (`unhandledrejection` ↔ `rejectionhandled`), not against your proxy handle.
+- ObjC exceptions never unwind through live V8 frames: boundaries catch on the JS side and rethrow after scope teardown, and crash-mode throws are deferred to a clean run-loop frame. Preserve this invariant when touching the boundary code.
diff --git a/package.json b/package.json
index a5e0c192..da5a9862 100644
--- a/package.json
+++ b/package.json
@@ -35,6 +35,7 @@
   "devDependencies": {
     "conventional-changelog-cli": "^2.1.1",
     "dayjs": "^1.11.7",
+    "esbuild": "0.28.1",
     "husky": "^9.0.11",
     "lint-staged": "^15.2.7",
     "semver": "^7.5.0"
@@ -44,4 +45,4 @@
       "clang-format -i"
     ]
   }
-}
\ No newline at end of file
+}
diff --git a/tools/js2c-inputs.xcfilelist b/tools/js2c-inputs.xcfilelist
new file mode 100644
index 00000000..abf8da2c
--- /dev/null
+++ b/tools/js2c-inputs.xcfilelist
@@ -0,0 +1,12 @@
+$(SRCROOT)/tools/js2c.mjs
+$(SRCROOT)/NativeScript/runtime/js/blob-url.js
+$(SRCROOT)/NativeScript/runtime/js/class-extends.js
+$(SRCROOT)/NativeScript/runtime/js/error-events.js
+$(SRCROOT)/NativeScript/runtime/js/events.js
+$(SRCROOT)/NativeScript/runtime/js/inline-functions.js
+$(SRCROOT)/NativeScript/runtime/js/placeholder-module.js
+$(SRCROOT)/NativeScript/runtime/js/promise-proxy.js
+$(SRCROOT)/NativeScript/runtime/js/require-factory.js
+$(SRCROOT)/NativeScript/runtime/js/smart-stringify.js
+$(SRCROOT)/NativeScript/runtime/js/ts-helpers.js
+$(SRCROOT)/NativeScript/runtime/js/weak-ref.js
diff --git a/tools/js2c-outputs.xcfilelist b/tools/js2c-outputs.xcfilelist
new file mode 100644
index 00000000..80d435af
--- /dev/null
+++ b/tools/js2c-outputs.xcfilelist
@@ -0,0 +1,2 @@
+$(SRCROOT)/NativeScript/runtime/generated/RuntimeBuiltins.h
+$(SRCROOT)/NativeScript/runtime/generated/RuntimeBuiltins.cpp
diff --git a/tools/js2c.mjs b/tools/js2c.mjs
new file mode 100644
index 00000000..7c9cd3e6
--- /dev/null
+++ b/tools/js2c.mjs
@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// Converts the runtime's builtin .js sources into a generated C++ table
+// (RuntimeBuiltins.h / RuntimeBuiltins.cpp) compiled into NativeScript.framework.
+// Invoked by the "Generate RuntimeBuiltins" build phase of the NativeScript target.
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { parseArgs } from 'node:util';
+
+const USAGE = `usage: node tools/js2c.mjs --out-dir <dir> [--minify] <file.js>...
+
+Generates <dir>/RuntimeBuiltins.h and <dir>/RuntimeBuiltins.cpp from the given
+builtin JavaScript sources. Builtin ids and script-origin names derive from the
+file names (promise-proxy.js -> BuiltinId::kPromiseProxy, "internal/promise-proxy.js").
+
+options:
+  --out-dir <dir>  output directory for the generated files (required)
+  --minify         minify sources with esbuild (whitespace + syntax only)
+  --help           show this message`;
+
+let args;
+try {
+  args = parseArgs({
+    options: {
+      'out-dir': { type: 'string' },
+      minify: { type: 'boolean', default: false },
+      help: { type: 'boolean', default: false },
+    },
+    allowPositionals: true,
+  });
+} catch (e) {
+  console.error(e.message);
+  console.error(USAGE);
+  process.exit(1);
+}
+if (args.values.help) {
+  console.log(USAGE);
+  process.exit(0);
+}
+const outDir = args.values['out-dir'];
+const inputs = args.positionals;
+if (!outDir || inputs.length === 0) {
+  console.error('error: --out-dir and at least one input file are required');
+  console.error(USAGE);
+  process.exit(1);
+}
+
+// Stable ordering regardless of shell glob order, so output never churns.
+inputs.sort((a, b) => basename(a).localeCompare(basename(b)));
+
+const builtins = [];
+for (const file of inputs) {
+  if (!existsSync(file)) {
+    console.error(`error: no such file: ${file}`);
+    process.exit(1);
+  }
+  const stem = basename(file).replace(/\.js$/, '');
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(stem)) {
+    console.error(`error: file name must be kebab-case .js: ${file}`);
+    process.exit(1);
+  }
+  let source = readFileSync(file, 'utf8');
+  if (args.values.minify) {
+    // Lazy import: esbuild is only needed when minification is requested.
+    const esbuild = await import('esbuild');
+    source = (await esbuild.transform(source, {
+      minifyWhitespace: true,
+      minifySyntax: true,
+      legalComments: 'none',
+    })).code;
+  }
+  const id = 'k' + stem.replace(/(^|-)([a-z0-9])/g, (_, __, c) => c.toUpperCase());
+  builtins.push({ stem, id, origin: `internal/${stem}.js`, source });
+}
+
+const ids = builtins.map((b) => `  ${b.id},`).join('\n');
+const header = `// generated by tools/js2c.mjs — do not edit
+#ifndef RUNTIMEBUILTINS_H_
+#define RUNTIMEBUILTINS_H_
+
+#include <cstddef>
+
+namespace tns {
+
+enum class BuiltinId : unsigned {
+${ids}
+  kCount,
+};
+
+struct BuiltinSource {
+  const char* name;    // script origin, e.g. "internal/promise-proxy.js"
+  const char* source;  // NUL-terminated UTF-8
+  size_t length;       // bytes, excluding the NUL
+};
+
+const BuiltinSource& GetBuiltinSource(BuiltinId id);
+
+}  // namespace tns
+
+#endif  // RUNTIMEBUILTINS_H_
+`;
+
+// Byte arrays sidestep every C string-literal escaping pitfall.
+function toByteArray(name, text) {
+  const bytes = Buffer.from(text, 'utf8');
+  const lines = [];
+  for (let i = 0; i < bytes.length; i += 16) {
+    lines.push('    ' + [...bytes.subarray(i, i + 16)].map((b) => `0x${b.toString(16).padStart(2, '0')},`).join(' '));
+  }
+  return `static const char ${name}[] = {\n${lines.join('\n')}\n    0x00};\n`;
+}
+
+const arrays = builtins
+  .map((b) => `// ${b.stem}.js\n${toByteArray(`kSource${b.id.slice(1)}`, b.source)}`)
+  .join('\n');
+const entries = builtins
+  .map((b) => `    {"${b.origin}", kSource${b.id.slice(1)}, sizeof(kSource${b.id.slice(1)}) - 1},`)
+  .join('\n');
+const impl = `// generated by tools/js2c.mjs — do not edit
+#include "RuntimeBuiltins.h"
+
+namespace tns {
+
+namespace {
+
+${arrays}
+const BuiltinSource kBuiltins[] = {
+${entries}
+};
+
+}  // namespace
+
+const BuiltinSource& GetBuiltinSource(BuiltinId id) {
+  return kBuiltins[static_cast<unsigned>(id)];
+}
+
+}  // namespace tns
+`;
+
+mkdirSync(outDir, { recursive: true });
+// Skip identical writes so downstream compilation isn't invalidated needlessly.
+for (const [name, content] of [['RuntimeBuiltins.h', header], ['RuntimeBuiltins.cpp', impl]]) {
+  const path = join(outDir, name);
+  if (existsSync(path) && readFileSync(path, 'utf8') === content) {
+    continue;
+  }
+  writeFileSync(path, content);
+}
+console.log(`js2c: generated ${builtins.length} builtins into ${outDir}`);
diff --git a/v8ios.xcodeproj/project.pbxproj b/v8ios.xcodeproj/project.pbxproj
index 4046a032..d89448b4 100644
--- a/v8ios.xcodeproj/project.pbxproj
+++ b/v8ios.xcodeproj/project.pbxproj
@@ -279,12 +279,20 @@
 		C2D71D7623E18C41000CD5F0 /* robin_hood.h in Headers */ = {isa = PBXBuildFile; fileRef = C2D71D7523E18C41000CD5F0 /* robin_hood.h */; };
 		C2D7E9D523F42C1100DB289C /* PromiseProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = C2D7E9D323F42C1100DB289C /* PromiseProxy.h */; };
 		C2D7E9D623F42C1100DB289C /* PromiseProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C2D7E9D423F42C1100DB289C /* PromiseProxy.cpp */; };
+		33118456DD6996CFA0F4BE94 /* ErrorEvents.h in Headers */ = {isa = PBXBuildFile; fileRef = AA8F22C26B03F50C6F191B8F /* ErrorEvents.h */; };
+		C79DADCF4D076CD80EE4ED13 /* ErrorEvents.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F5D0708037B4A4ACBC03CBF9 /* ErrorEvents.cpp */; };
+		5E6BCFCA78A8AE651EB78180 /* Events.h in Headers */ = {isa = PBXBuildFile; fileRef = 76C6D020ADB0F5972F3110F1 /* Events.h */; };
+		462FA976C64356112F69C395 /* Events.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 57F19E556878D1CF14C0EA04 /* Events.cpp */; };
+		679FAFBB859D754E68A0C745 /* NSExceptionSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 63E0497723B11A51D45A1818 /* NSExceptionSupport.h */; };
+		4C4DD7153616866C54B2CD47 /* NSExceptionSupport.mm in Sources */ = {isa = PBXBuildFile; fileRef = E9A2699467FF325411FC11C4 /* NSExceptionSupport.mm */; };
 		C2DDEB8D229EAC8300345BFE /* Common.h in Headers */ = {isa = PBXBuildFile; fileRef = C2DDEB64229EAC8100345BFE /* Common.h */; };
 		C2DDEB8E229EAC8300345BFE /* Interop.h in Headers */ = {isa = PBXBuildFile; fileRef = C2DDEB65229EAC8100345BFE /* Interop.h */; };
 		C2DDEB8F229EAC8300345BFE /* ArgConverter.h in Headers */ = {isa = PBXBuildFile; fileRef = C2DDEB66229EAC8100345BFE /* ArgConverter.h */; };
 		C2DDEB90229EAC8300345BFE /* MetadataBuilder.h in Headers */ = {isa = PBXBuildFile; fileRef = C2DDEB67229EAC8100345BFE /* MetadataBuilder.h */; };
 		C2DDEB91229EAC8300345BFE /* FFICall.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C2DDEB68229EAC8100345BFE /* FFICall.cpp */; };
 		C2DDEB92229EAC8300345BFE /* WeakRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C2DDEB69229EAC8100345BFE /* WeakRef.cpp */; };
+		4A5C201A2E2B000100000006 /* BuiltinLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4A5C201A2E2B000100000001 /* BuiltinLoader.cpp */; };
+		4A5C201A2E2B000100000007 /* RuntimeBuiltins.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4A5C201A2E2B000100000003 /* RuntimeBuiltins.cpp */; };
 		C2DDEB93229EAC8300345BFE /* ArgConverter.mm in Sources */ = {isa = PBXBuildFile; fileRef = C2DDEB6A229EAC8200345BFE /* ArgConverter.mm */; };
 		C2DDEB94229EAC8300345BFE /* Console.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C2DDEB6B229EAC8200345BFE /* Console.cpp */; };
 		C2DDEB95229EAC8300345BFE /* SetTimeout.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C2DDEB6C229EAC8200345BFE /* SetTimeout.cpp */; };
@@ -782,6 +790,12 @@
 		C2D71D7523E18C41000CD5F0 /* robin_hood.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = robin_hood.h; sourceTree = "<group>"; };
 		C2D7E9D323F42C1100DB289C /* PromiseProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PromiseProxy.h; sourceTree = "<group>"; };
 		C2D7E9D423F42C1100DB289C /* PromiseProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PromiseProxy.cpp; sourceTree = "<group>"; };
+		AA8F22C26B03F50C6F191B8F /* ErrorEvents.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ErrorEvents.h; sourceTree = "<group>"; };
+		F5D0708037B4A4ACBC03CBF9 /* ErrorEvents.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ErrorEvents.cpp; sourceTree = "<group>"; };
+		76C6D020ADB0F5972F3110F1 /* Events.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Events.h; sourceTree = "<group>"; };
+		57F19E556878D1CF14C0EA04 /* Events.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Events.cpp; sourceTree = "<group>"; };
+		63E0497723B11A51D45A1818 /* NSExceptionSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NSExceptionSupport.h; sourceTree = "<group>"; };
+		E9A2699467FF325411FC11C4 /* NSExceptionSupport.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = NSExceptionSupport.mm; sourceTree = "<group>"; };
 		C2DDEB16229EA89000345BFE /* TestRunner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = TestRunner.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		C2DDEB26229EA89200345BFE /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		C2DDEB32229EAB3B00345BFE /* NativeScript.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = NativeScript.framework; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -793,6 +807,11 @@
 		C2DDEB67229EAC8100345BFE /* MetadataBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MetadataBuilder.h; sourceTree = "<group>"; };
 		C2DDEB68229EAC8100345BFE /* FFICall.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FFICall.cpp; sourceTree = "<group>"; };
 		C2DDEB69229EAC8100345BFE /* WeakRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WeakRef.cpp; sourceTree = "<group>"; };
+		4A5C201A2E2B000100000001 /* BuiltinLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BuiltinLoader.cpp; sourceTree = "<group>"; };
+		4A5C201A2E2B000100000002 /* BuiltinLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BuiltinLoader.h; sourceTree = "<group>"; };
+		4A5C201A2E2B000100000003 /* RuntimeBuiltins.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RuntimeBuiltins.cpp; path = generated/RuntimeBuiltins.cpp; sourceTree = "<group>"; };
+		4A5C201A2E2B000100000004 /* RuntimeBuiltins.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RuntimeBuiltins.h; path = generated/RuntimeBuiltins.h; sourceTree = "<group>"; };
+		4A5C201A2E2B000100000005 /* js */ = {isa = PBXFileReference; lastKnownFileType = folder; path = js; sourceTree = "<group>"; };
 		C2DDEB6A229EAC8200345BFE /* ArgConverter.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ArgConverter.mm; sourceTree = "<group>"; };
 		C2DDEB6B229EAC8200345BFE /* Console.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Console.cpp; sourceTree = "<group>"; };
 		C2DDEB6C229EAC8200345BFE /* SetTimeout.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SetTimeout.cpp; sourceTree = "<group>"; };
@@ -1436,6 +1455,10 @@
 				AA5DBFD62EC19216008D12F9 /* DevFlags.mm */,
 				C2DDEB85229EAC8300345BFE /* DictionaryAdapter.h */,
 				C2DDEB8B229EAC8300345BFE /* DictionaryAdapter.mm */,
+				AA8F22C26B03F50C6F191B8F /* ErrorEvents.h */,
+				F5D0708037B4A4ACBC03CBF9 /* ErrorEvents.cpp */,
+				76C6D020ADB0F5972F3110F1 /* Events.h */,
+				57F19E556878D1CF14C0EA04 /* Events.cpp */,
 				C2A5F8692359AEB600074AFA /* ExtVector.h */,
 				C2A5F8682359AEB500074AFA /* ExtVector.cpp */,
 				C2CC8EE922BBA01E00B78928 /* FastEnumerationAdapter.h */,
@@ -1468,6 +1491,8 @@
 				2B7EA6AD2353476F00E5184E /* NativeScriptException.mm */,
 				C266567A22AA630F00EE15CC /* NSDataAdapter.h */,
 				C266567922AA630F00EE15CC /* NSDataAdapter.mm */,
+				63E0497723B11A51D45A1818 /* NSExceptionSupport.h */,
+				E9A2699467FF325411FC11C4 /* NSExceptionSupport.mm */,
 				C2DDEB83229EAC8300345BFE /* ObjectManager.h */,
 				C2DDEB86229EAC8300345BFE /* ObjectManager.mm */,
 				C20AB5E526E1015200E2B41D /* OneByteStringResource.h */,
@@ -1499,6 +1524,11 @@
 				C298C025233C9AEA000DDF54 /* TSHelpers.cpp */,
 				C2DDEB82229EAC8200345BFE /* WeakRef.h */,
 				C2DDEB69229EAC8100345BFE /* WeakRef.cpp */,
+				4A5C201A2E2B000100000002 /* BuiltinLoader.h */,
+				4A5C201A2E2B000100000001 /* BuiltinLoader.cpp */,
+				4A5C201A2E2B000100000004 /* RuntimeBuiltins.h */,
+				4A5C201A2E2B000100000003 /* RuntimeBuiltins.cpp */,
+				4A5C201A2E2B000100000005 /* js */,
 				3CD1D9BF29AA2C14004C1C21 /* DisposerPHV.mm */,
 				3CD1D9C029AA2C14004C1C21 /* DisposerPHV.h */,
 				C22C092122CA3F370080D176 /* Worker.h */,
@@ -1623,6 +1653,9 @@
 				C2DDEBA1229EAC8300345BFE /* FFICall.h in Headers */,
 				C266567C22AA630F00EE15CC /* NSDataAdapter.h in Headers */,
 				C2D7E9D523F42C1100DB289C /* PromiseProxy.h in Headers */,
+				33118456DD6996CFA0F4BE94 /* ErrorEvents.h in Headers */,
+				5E6BCFCA78A8AE651EB78180 /* Events.h in Headers */,
+				679FAFBB859D754E68A0C745 /* NSExceptionSupport.h in Headers */,
 				C2A5F86B2359AEB600074AFA /* ExtVector.h in Headers */,
 				3C5333352B0E683100BE0C47 /* Message.hpp in Headers */,
 				C2DDEBB0229EAC8300345BFE /* StringHasher.h in Headers */,
@@ -1782,6 +1815,7 @@
 			buildConfigurationList = C2DDEB37229EAB3B00345BFE /* Build configuration list for PBXNativeTarget "NativeScript" */;
 			buildPhases = (
 				C2DDEB2D229EAB3B00345BFE /* Headers */,
+				4A5C201A2E2B000100000008 /* Generate RuntimeBuiltins */,
 				C2DDEB2E229EAB3B00345BFE /* Sources */,
 				C2DDEB2F229EAB3B00345BFE /* Frameworks */,
 				C2DDEB30229EAB3B00345BFE /* Resources */,
@@ -1918,6 +1952,26 @@
 /* End PBXResourcesBuildPhase section */
 
 /* Begin PBXShellScriptBuildPhase section */
+		4A5C201A2E2B000100000008 /* Generate RuntimeBuiltins */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+				"$(SRCROOT)/tools/js2c-inputs.xcfilelist",
+			);
+			inputPaths = (
+			);
+			name = "Generate RuntimeBuiltins";
+			outputFileListPaths = (
+				"$(SRCROOT)/tools/js2c-outputs.xcfilelist",
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "set -e\nexport PATH=\"$PATH:/opt/homebrew/bin:/usr/local/bin\"\nif ! command -v node >/dev/null 2>&1; then\n  echo \"error: node is required to generate the runtime builtins (tools/js2c.mjs); install Node.js or add it to PATH\" >&2\n  exit 1\nfi\ncd \"${SRCROOT}\"\nnode tools/js2c.mjs --out-dir NativeScript/runtime/generated NativeScript/runtime/js/*.js\n";
+		};
 		2BFE21F02AC1B28000307752 /* Add default metadata */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
@@ -2227,6 +2281,8 @@
 				C20AB5E626E1015300E2B41D /* OneByteStringResource.cpp in Sources */,
 				6573B9CE291FE29F00B0ED7C /* JSIV8ValueConverter.cpp in Sources */,
 				C2DDEB92229EAC8300345BFE /* WeakRef.cpp in Sources */,
+				4A5C201A2E2B000100000006 /* BuiltinLoader.cpp in Sources */,
+				4A5C201A2E2B000100000007 /* RuntimeBuiltins.cpp in Sources */,
 				C2A5F86A2359AEB600074AFA /* ExtVector.cpp in Sources */,
 				AA8C47B22E27114300649BF5 /* ModuleInternalCallbacks.mm in Sources */,
 				C2DDEBAF229EAC8300345BFE /* ObjectManager.mm in Sources */,
@@ -2279,6 +2335,9 @@
 				C2C8EE7422CE3266001F8CEC /* ConcurrentQueue.cpp in Sources */,
 				C2DDEBA0229EAC8300345BFE /* Interop.mm in Sources */,
 				C2D7E9D623F42C1100DB289C /* PromiseProxy.cpp in Sources */,
+				C79DADCF4D076CD80EE4ED13 /* ErrorEvents.cpp in Sources */,
+				462FA976C64356112F69C395 /* Events.cpp in Sources */,
+				4C4DD7153616866C54B2CD47 /* NSExceptionSupport.mm in Sources */,
 				3CEA20DC2A7DA8320009BE8F /* IsolateWrapper.cpp in Sources */,
 				C275F477253B37AB00A997D5 /* UnmanagedType.mm in Sources */,
 				C266569E22B282BA00EE15CC /* FunctionReference.cpp in Sources */,
@@ -2919,6 +2978,7 @@
 					"$(SRCROOT)/NativeScript/inspector",
 					"$(SRCROOT)/NativeScript/v8runtime",
 					"$(SRCROOT)/NativeScript/jsi",
+					"$(SRCROOT)/NativeScript/runtime/generated",
 				);
 				VERSIONING_SYSTEM = "apple-generic";
 				VERSION_INFO_PREFIX = "";
@@ -3011,6 +3071,7 @@
 					"$(SRCROOT)/NativeScript/inspector",
 					"$(SRCROOT)/NativeScript/v8runtime",
 					"$(SRCROOT)/NativeScript/jsi",
+					"$(SRCROOT)/NativeScript/runtime/generated",
 				);
 				VERSIONING_SYSTEM = "apple-generic";
 				VERSION_INFO_PREFIX = "";