feat: full test coverage on macos & ios, v8 14

.gitignore

@@ -59,4 +59,7 @@ v8_build
 
 .cache/
 
+dist
+packages/*/types
+
 SwiftBindgen

NativeScript/CMakeLists.txt

@@ -78,7 +78,6 @@ elseif(TARGET_ENGINE STREQUAL "hermes")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -std=c++20 -DTARGET_ENGINE_HERMES")
 elseif(TARGET_ENGINE STREQUAL "v8")
   set(TARGET_ENGINE_V8 TRUE)
-  add_link_options("-fuse-ld=lld")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -stdlib=libc++ -std=c++20 -DTARGET_ENGINE_V8")
 elseif(TARGET_ENGINE STREQUAL "quickjs")
   set(TARGET_ENGINE_QUICKJS TRUE)
@@ -152,10 +151,13 @@ if(ENABLE_JS_RUNTIME)
     runtime/modules/worker/WorkerImpl.mm
     runtime/modules/worker/WorkerImpl.mm
     runtime/modules/module/ModuleInternal.cpp
+    runtime/modules/node/Node.cpp
+    runtime/modules/node/FS.cpp
     runtime/modules/performance/Performance.cpp
     runtime/Bundle.mm
     runtime/modules/timers/Timers.mm
     runtime/modules/app/App.mm
+    runtime/modules/web/Web.mm
     runtime/NativeScript.mm
     runtime/RuntimeConfig.cpp
     runtime/modules/url/ada/ada.cpp
@@ -166,7 +168,6 @@ if(ENABLE_JS_RUNTIME)
   if(TARGET_ENGINE_V8)
     include_directories(
       napi/v8
-      napi/v8/include
       napi/v8/v8_inspector
     )
 
@@ -292,6 +293,17 @@ target_sources(
   "NativeScript.h"
 )
 
+if(TARGET_ENGINE_V8 AND TARGET_PLATFORM_IOS)
+  # iOS V8 slices are built with pointer compression enabled. Keep embedder
+  # build flags in sync to satisfy V8::Initialize() build config checks.
+  target_compile_definitions(
+    ${NAME}
+    PRIVATE
+    V8_COMPRESS_POINTERS
+    V8_31BIT_SMIS_ON_64BIT_ARCH
+  )
+endif()
+
 set(FRAMEWORK_VERSION_VALUE "${VERSION}")
 if(TARGET_PLATFORM_MACOS)
   # macOS framework consumers (including Xcode's copy/sign phases) expect
@@ -392,27 +404,42 @@ if(TARGET_ENGINE_JSC)
 endif()
 
 if(TARGET_ENGINE_V8)
-  if(TARGET_PLATFORM_MACOS)
-    target_link_directories(
-      ${NAME}
-      PRIVATE
-      ${CMAKE_CURRENT_SOURCE_DIR}/../Frameworks/v8_macos
-    )
+  add_library(v8::monolith STATIC IMPORTED GLOBAL)
+
+  set(V8_XCFRAMEWORK "${CMAKE_SOURCE_DIR}/../Frameworks/libv8_monolith.xcframework")
+
+  # Decide platform + slice
+  if(APPLE)
+    if(TARGET_PLATFORM STREQUAL "ios-sim")
+        # Prefer universal sim slice if present
+        set(V8_SLICE_DIR "${V8_XCFRAMEWORK}/ios-arm64-simulator/libv8_monolith.framework")
+        if(NOT EXISTS "${V8_SLICE_DIR}")
+          set(V8_SLICE_DIR "${V8_XCFRAMEWORK}/ios-arm64-simulator/libv8_monolith.framework") # fallback
+        endif()
+    elseif(TARGET_PLATFORM STREQUAL "ios")
+        # Prefer universal sim slice if present
+        set(V8_SLICE_DIR "${V8_XCFRAMEWORK}/ios-arm64/libv8_monolith.framework")
+        if(NOT EXISTS "${V8_SLICE_DIR}")
+          set(V8_SLICE_DIR "${V8_XCFRAMEWORK}/ios-arm64/libv8_monolith.framework") # fallback
+        endif()
+    else()
+      # macOS
+      set(V8_SLICE_DIR "${V8_XCFRAMEWORK}/macos-arm64/libv8_monolith.framework")
+      if(NOT EXISTS "${V8_SLICE_DIR}")
+        set(V8_SLICE_DIR "${V8_XCFRAMEWORK}/macos-arm64/libv8_monolith.framework") # keep same, just explicit
+      endif()
+    endif()
   else()
-    target_link_directories(
-      ${NAME}
-      PRIVATE
-      ${CMAKE_CURRENT_SOURCE_DIR}/../Frameworks/v8_ios
-    )
+    message(FATAL_ERROR "This example is for Apple platforms only.")
   endif()
 
-  target_link_libraries(
-    ${NAME}
-    PRIVATE
-    "v8_monolith"
-    "v8_libbase"
-    "v8_libplatform"
+  # Point imported lib at the slice
+  set_target_properties(v8::monolith PROPERTIES
+    IMPORTED_LOCATION "${V8_SLICE_DIR}/libv8_monolith"
+    INTERFACE_INCLUDE_DIRECTORIES "${V8_SLICE_DIR}/Headers"
   )
+
+  target_link_libraries(${NAME} PRIVATE v8::monolith)
 endif()
 
 target_link_libraries(

NativeScript/ffi/Block.h

@@ -14,16 +14,22 @@ class FunctionPointer {
   void* function;
   metagen::MDSectionOffset offset;
   Cif* cif;
+  bool ownsCif = false;
 
   static napi_value wrap(napi_env env, void* function,
                          metagen::MDSectionOffset offset, bool isBlock);
+  static napi_value wrapWithEncoding(napi_env env, void* function,
+                                     const char* encoding, bool isBlock);
   static void finalize(napi_env env, void* finalize_data, void* finalize_hint);
 
   static napi_value jsCallAsCFunction(napi_env env, napi_callback_info cbinfo);
   static napi_value jsCallAsBlock(napi_env env, napi_callback_info cbinfo);
 };
 
 id registerBlock(napi_env env, Closure* closure, napi_value callback);
+napi_value getCachedBlockCallback(napi_env env, void* blockPtr);
+bool isObjCBlockObject(id obj);
+const char* getObjCBlockSignature(void* blockPtr);
 
 NAPI_FUNCTION(registerBlock);
 

NativeScript/ffi/Block.mm

@@ -1,12 +1,14 @@
 #include "Block.h"
 #import <Foundation/Foundation.h>
+#include <cstdint>
+#include <cstring>
+#include <unordered_map>
 #include "Interop.h"
 #include "ObjCBridge.h"
 #include "js_native_api.h"
 #include "js_native_api_types.h"
 #include "node_api_util.h"
 #include "objc/runtime.h"
-#include <cstring>
 
 struct Block_descriptor_1 {
   unsigned long int reserved;  // NULL
@@ -33,6 +35,8 @@
 constexpr int kBlockNeedsFree = (1 << 24);
 constexpr int kBlockHasCopyDispose = (1 << 25);
 constexpr int kBlockRefCountOne = (1 << 1);
+constexpr int kBlockHasSignature = (1 << 30);
+std::unordered_map<void*, napi_ref> g_blockToJsFunction;
 
 void block_copy(void* dest, void* src) {
   auto dst = static_cast<Block_literal_1*>(dest);
@@ -46,6 +50,14 @@ void block_release(void* src) {
     return;
   }
 
+  if (block->closure != nullptr && block->closure->env != nullptr) {
+    auto it = g_blockToJsFunction.find(block);
+    if (it != g_blockToJsFunction.end()) {
+      napi_delete_reference(block->closure->env, it->second);
+      g_blockToJsFunction.erase(it);
+    }
+  }
+
   if (block->closure != nullptr) {
     delete block->closure;
     block->closure = nullptr;
@@ -60,6 +72,30 @@ void block_release(void* src) {
     .signature = nullptr,
 };
 
+inline napi_value getCachedBlockJsFunction(napi_env env, void* blockPtr) {
+  auto it = g_blockToJsFunction.find(blockPtr);
+  if (it == g_blockToJsFunction.end()) {
+    return nullptr;
+  }
+  napi_value value = nativescript::get_ref_value(env, it->second);
+  if (value == nullptr) {
+    napi_delete_reference(env, it->second);
+    g_blockToJsFunction.erase(it);
+  }
+  return value;
+}
+
+inline void cacheBlockJsFunction(napi_env env, void* blockPtr, napi_value jsFunction) {
+  if (blockPtr == nullptr || jsFunction == nullptr) {
+    return;
+  }
+  if (g_blockToJsFunction.find(blockPtr) != g_blockToJsFunction.end()) {
+    return;
+  }
+  // Keep this weak so callback identity can round-trip without preventing GC.
+  g_blockToJsFunction[blockPtr] = nativescript::make_ref(env, jsFunction, 0);
+}
+
 }  // namespace
 
 void block_finalize(napi_env env, void* data, void* hint) {
@@ -68,6 +104,12 @@ void block_finalize(napi_env env, void* data, void* hint) {
     return;
   }
 
+  auto it = g_blockToJsFunction.find(block);
+  if (it != g_blockToJsFunction.end()) {
+    napi_delete_reference(env, it->second);
+    g_blockToJsFunction.erase(it);
+  }
+
   if (block->closure != nullptr) {
     delete block->closure;
     block->closure = nullptr;
@@ -102,6 +144,12 @@ id registerBlock(napi_env env, Closure* closure, napi_value callback) {
 
   closure->func = make_ref(env, callback, 1);
 
+  // Expose the native block pointer on the JS callback so interop.handleof/sizeof
+  // can resolve pointers for blocks that round-trip through Objective-C.
+  napi_value ptrExternal;
+  napi_create_external(env, block, nullptr, nullptr, &ptrExternal);
+  napi_set_named_property(env, callback, "__ns_native_ptr", ptrExternal);
+
   auto bridgeState = ObjCBridgeState::InstanceData(env);
 
 #ifndef ENABLE_JS_RUNTIME
@@ -114,9 +162,59 @@ id registerBlock(napi_env env, Closure* closure, napi_value callback) {
   }
 #endif  // ENABLE_JS_RUNTIME
 
+  cacheBlockJsFunction(env, block, callback);
+
   return (id)block;
 }
 
+napi_value getCachedBlockCallback(napi_env env, void* blockPtr) {
+  return getCachedBlockJsFunction(env, blockPtr);
+}
+
+bool isObjCBlockObject(id obj) {
+  if (obj == nil) {
+    return false;
+  }
+
+  Class cls = object_getClass(obj);
+  if (cls == nil) {
+    return false;
+  }
+
+  const char* className = class_getName(cls);
+  if (className == nullptr) {
+    return false;
+  }
+
+  // Runtime block classes are typically internal names like
+  // __NSGlobalBlock__, __NSMallocBlock__, __NSStackBlock__.
+  return className[0] == '_' && className[1] == '_' && strstr(className, "Block") != nullptr;
+}
+
+const char* getObjCBlockSignature(void* blockPtr) {
+  auto block = static_cast<Block_literal_1*>(blockPtr);
+  if (block == nullptr || block->descriptor == nullptr) {
+    return nullptr;
+  }
+
+  if ((block->flags & kBlockHasSignature) == 0) {
+    return nullptr;
+  }
+
+  // Descriptor layout:
+  // unsigned long reserved;
+  // unsigned long size;
+  // [copy_helper, dispose_helper] if BLOCK_HAS_COPY_DISPOSE
+  // const char* signature if BLOCK_HAS_SIGNATURE
+  auto descriptorCursor = reinterpret_cast<uint8_t*>(block->descriptor);
+  descriptorCursor += sizeof(unsigned long) * 2;
+  if ((block->flags & kBlockHasCopyDispose) != 0) {
+    descriptorCursor += sizeof(void*) * 2;
+  }
+
+  return *reinterpret_cast<const char**>(descriptorCursor);
+}
+
 NAPI_FUNCTION(registerBlock) {
   NAPI_CALLBACK_BEGIN(2)
 
@@ -137,6 +235,13 @@ id registerBlock(napi_env env, Closure* closure, napi_value callback) {
 
 napi_value FunctionPointer::wrap(napi_env env, void* function, metagen::MDSectionOffset offset,
                                  bool isBlock) {
+  if (isBlock) {
+    napi_value cached = getCachedBlockJsFunction(env, function);
+    if (cached != nullptr) {
+      return cached;
+    }
+  }
+
   FunctionPointer* ref = new FunctionPointer();
   ref->function = function;
   ref->offset = offset;
@@ -153,6 +258,77 @@ id registerBlock(napi_env env, Closure* closure, napi_value callback) {
   napi_create_function(env, isBlock ? "objcBlockWrapper" : "cFunctionWrapper", NAPI_AUTO_LENGTH,
                        isBlock ? jsCallAsBlock : jsCallAsCFunction, ref, &result);
 
+  // Allow fast pointer extraction when JS function wrappers are passed back to native.
+  napi_ref nativePointerRef;
+  napi_wrap(env, result, function, nullptr, nullptr, &nativePointerRef);
+  (void)nativePointerRef;
+
+  // Keep raw pointer metadata without overriding the function callback data.
+  // Overriding callback data breaks JS invocation for wrapped function pointers.
+  napi_value ptrExternal;
+  napi_create_external(env, function, nullptr, nullptr, &ptrExternal);
+  napi_property_descriptor ptrProp = {
+      .utf8name = "__ns_native_ptr",
+      .method = nullptr,
+      .getter = nullptr,
+      .setter = nullptr,
+      .value = ptrExternal,
+      .attributes = napi_default,
+      .data = nullptr,
+  };
+  napi_define_properties(env, result, 1, &ptrProp);
+
+  napi_ref jsRef;
+  napi_add_finalizer(env, result, ref, FunctionPointer::finalize, nullptr, &jsRef);
+
+  return result;
+}
+
+napi_value FunctionPointer::wrapWithEncoding(napi_env env, void* function, const char* encoding,
+                                             bool isBlock) {
+  if (function == nullptr || encoding == nullptr || encoding[0] == '\0') {
+    napi_value nullValue;
+    napi_get_null(env, &nullValue);
+    return nullValue;
+  }
+
+  if (isBlock) {
+    napi_value cached = getCachedBlockJsFunction(env, function);
+    if (cached != nullptr) {
+      return cached;
+    }
+  }
+
+  FunctionPointer* ref = new FunctionPointer();
+  ref->function = function;
+  ref->offset = 0;
+  ref->ownsCif = true;
+  ref->cif = new Cif(env, encoding, isBlock ? 1 : 0);
+
+  napi_value result;
+  napi_create_function(env, isBlock ? "objcBlockWrapper" : "cFunctionWrapper", NAPI_AUTO_LENGTH,
+                       isBlock ? jsCallAsBlock : jsCallAsCFunction, ref, &result);
+
+  // Allow fast pointer extraction when JS function wrappers are passed back to native.
+  napi_ref nativePointerRef;
+  napi_wrap(env, result, function, nullptr, nullptr, &nativePointerRef);
+  (void)nativePointerRef;
+
+  // Keep raw pointer metadata without overriding the function callback data.
+  // Overriding callback data breaks JS invocation for wrapped function pointers.
+  napi_value ptrExternal;
+  napi_create_external(env, function, nullptr, nullptr, &ptrExternal);
+  napi_property_descriptor ptrProp = {
+      .utf8name = "__ns_native_ptr",
+      .method = nullptr,
+      .getter = nullptr,
+      .setter = nullptr,
+      .value = ptrExternal,
+      .attributes = napi_default,
+      .data = nullptr,
+  };
+  napi_define_properties(env, result, 1, &ptrProp);
+
   napi_ref jsRef;
   napi_add_finalizer(env, result, ref, FunctionPointer::finalize, nullptr, &jsRef);
 
@@ -161,6 +337,10 @@ id registerBlock(napi_env env, Closure* closure, napi_value callback) {
 
 void FunctionPointer::finalize(napi_env env, void* finalize_data, void* finalize_hint) {
   auto ref = (FunctionPointer*)finalize_data;
+  if (ref->ownsCif && ref->cif != nullptr) {
+    delete ref->cif;
+    ref->cif = nullptr;
+  }
   delete ref;
 }