N-API v7 across runtimes (V8 / JavaScriptCore / Chakra)

CMakeLists.txt

@@ -58,6 +58,14 @@ set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+# A newer MSVC (windows-latest) emits C4875 ("a non-string literal argument to [[gsl::suppress]] is
+# deprecated") from the vendored GSL headers, which several targets compile with warnings-as-error.
+# Suppress this dependency-side deprecation so the Windows build isn't broken by toolchain drift. Must
+# be set before arcana.cpp / Core / Polyfills are added below so they inherit it.
+if(MSVC)
+    add_compile_options(/wd4875)
+endif()
+
 # --------------------------------------------------
 # Options
 # --------------------------------------------------
@@ -135,6 +143,17 @@ endif()
 FetchContent_MakeAvailable_With_Message(arcana.cpp)
 set_property(TARGET arcana PROPERTY FOLDER Dependencies)
 
+if(ANDROID)
+    FetchContent_GetProperties(AndroidExtensions)
+    if(NOT AndroidExtensions_POPULATED)
+        FetchContent_Populate(AndroidExtensions)
+        FetchContent_GetProperties(AndroidExtensions)
+        add_subdirectory(${androidextensions_SOURCE_DIR} ${androidextensions_BINARY_DIR})
+    else()
+        add_subdirectory(${androidextensions_SOURCE_DIR} ${androidextensions_BINARY_DIR})
+    endif()
+endif()
+
 if(JSRUNTIMEHOST_POLYFILL_XMLHTTPREQUEST)
     FetchContent_MakeAvailable_With_Message(UrlLib)
     set_property(TARGET UrlLib PROPERTY FOLDER Dependencies)

Core/Node-API-JSI/CMakeLists.txt

@@ -57,7 +57,12 @@ if(NOT TARGET jsi)
 endif()
 
 target_include_directories(napi
-    PUBLIC "include")
+    PUBLIC "include"
+    # napi.h pulls in the shared <napi/js_native_api_types.h>, which lives in
+    # Core/Node-API/Include/Shared. That sibling isn't built when the engine is JSI
+    # (Core/CMakeLists.txt selects Node-API-JSI instead of Node-API), so reference the shared
+    # headers directly here -- otherwise the JSI napi fails to compile with C1083.
+    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../Node-API/Include/Shared")
 
 target_link_libraries(napi
     PUBLIC jsi)

Core/Node-API-JSI/Include/napi/napi.h

@@ -1,49 +1,14 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <napi/js_native_api_types.h>
 #include <functional>
 #include <initializer_list>
 #include <memory>
 #include <string>
 #include <vector>
 #include <optional>
 
-// Copied from js_native_api_types.h (https://git.io/J8aI5)
-typedef enum {
-  napi_default = 0,
-  napi_writable = 1 << 0,
-  napi_enumerable = 1 << 1,
-  napi_configurable = 1 << 2,
-} napi_property_attributes;
-
-typedef enum {
-  // ES6 types (corresponds to typeof)
-  napi_undefined,
-  napi_null,
-  napi_boolean,
-  napi_number,
-  napi_string,
-  napi_symbol,
-  napi_object,
-  napi_function,
-  napi_external,
-} napi_valuetype;
-
-typedef enum {
-  napi_int8_array,
-  napi_uint8_array,
-  napi_uint8_clamped_array,
-  napi_int16_array,
-  napi_uint16_array,
-  napi_int32_array,
-  napi_uint32_array,
-  napi_float32_array,
-  napi_float64_array,
-  // JSI doesn't support bigint.
-  // napi_bigint64_array,
-  // napi_biguint64_array,
-} napi_typedarray_type;
-
 struct napi_env__ {
   napi_env__(facebook::jsi::Runtime& rt)
     : rt{rt}

Core/Node-API/CMakeLists.txt

@@ -7,7 +7,10 @@ elseif(ANDROID)
     set(NAPI_JAVASCRIPT_ENGINE "V8" CACHE STRING "JavaScript engine for Node-API")
 elseif(UNIX)
     set(NAPI_JAVASCRIPT_ENGINE "JavaScriptCore" CACHE STRING "JavaScript engine for Node-API")
-    set(JAVASCRIPTCORE_LIBRARY "/usr/lib/x86_64-linux-gnu/libjavascriptcoregtk-4.1.so" CACHE STRING "Path to the JavaScriptCore shared library")
+    find_library(JAVASCRIPTCORE_LIBRARY javascriptcoregtk-4.1)
+    if(NOT JAVASCRIPTCORE_LIBRARY)
+        message(FATAL_ERROR "JavaScriptCore library not found. Please install libwebkit2gtk-4.1-dev")
+    endif()
 else()
     message(FATAL_ERROR "Unable to select Node-API JavaScript engine for platform")
 endif()
@@ -152,10 +155,33 @@ if(NAPI_BUILD_ABI)
     message(STATUS "Selected ${NAPI_JAVASCRIPT_ENGINE}")
 endif()
 
-add_library(napi ${SOURCES})
+# On Android, native addons are dlopen'd as standalone .node modules and resolve their napi_* imports
+# from a shared napi at load time -- bionic will not surface a statically-linked host's napi to a
+# dlopen'd module, so the host and every addon must share a single libnapi.so. Default napi to a
+# shared library on Android so that model works out of the box; an integrator who wants a static napi
+# (e.g. for size/packaging) can override with -DJSR_NAPI_SHARED=OFF. The option defaults OFF on other
+# platforms, where napi keeps following the project's default library type (i.e. honors
+# BUILD_SHARED_LIBS).
+set(JSR_NAPI_SHARED_DEFAULT OFF)
+if(ANDROID)
+    set(JSR_NAPI_SHARED_DEFAULT ON)
+endif()
+option(JSR_NAPI_SHARED "Build napi as a shared library (libnapi.so)" ${JSR_NAPI_SHARED_DEFAULT})
+
+if(JSR_NAPI_SHARED)
+    add_library(napi SHARED ${SOURCES})
+else()
+    add_library(napi ${SOURCES})
+endif()
 
 target_include_directories(napi ${INCLUDE_DIRECTORIES})
 target_link_libraries(napi ${LINK_LIBRARIES})
 
+# Expose the selected engine as a compile definition so engine-agnostic consumers (the node_lite test
+# harness) can branch on engine capability instead of guessing from the platform
+# (__APPLE__ == JSC / __ANDROID__ == V8 breaks Android-JSC, Linux-V8, Windows-Chakra, ...).
+string(TOUPPER "${NAPI_JAVASCRIPT_ENGINE}" NAPI_ENGINE_UPPER)
+target_compile_definitions(napi PUBLIC JSR_NAPI_ENGINE_${NAPI_ENGINE_UPPER})
+
 set_property(TARGET napi PROPERTY FOLDER Dependencies)
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES})

Core/Node-API/Include/Shared/napi/js_native_api.h

@@ -3,7 +3,7 @@
 
 // [BABYLON-NATIVE-ADDITION]
 #ifndef NAPI_VERSION
-#define NAPI_VERSION 5
+#define NAPI_VERSION 7
 #endif
 
 // This file needs to be compatible with C compilers.

Core/Node-API/Include/Shared/napi/js_native_api_types.h

@@ -3,7 +3,7 @@
 
 // [BABYLON-NATIVE-ADDITION]
 #ifndef NAPI_VERSION
-#define NAPI_VERSION 5
+#define NAPI_VERSION 7
 #endif
 
 // This file needs to be compatible with C compilers.

Core/Node-API/Source/js_native_api_chakra.cc

@@ -2419,6 +2419,79 @@ napi_status napi_run_script(napi_env env,
   return napi_ok;
 }
 
+// === N-API v6 / v7 ===
+//
+// napi_set_instance_data / napi_get_instance_data (v6): per-env data slot, finalized at env teardown
+// by ~napi_env__ (see js_native_api_chakra.h).
+napi_status napi_set_instance_data(napi_env env,
+                                   void* data,
+                                   napi_finalize finalize_cb,
+                                   void* finalize_hint) {
+  CHECK_ENV(env);
+  env->instance_data = data;
+  env->instance_data_finalize_cb = finalize_cb;
+  env->instance_data_finalize_hint = finalize_hint;
+  return napi_ok;
+}
+
+napi_status napi_get_instance_data(napi_env env, void** data) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, data);
+  *data = env->instance_data;
+  return napi_ok;
+}
+
+// BigInt (v6): the Win10 OS edge-mode Chakra (jsrt) predates BigInt and exposes no JsBigInt* API, so
+// there is no value-preserving fallback. Per the Node-API feature-detection-by-exception pattern, throw
+// a JS-catchable error tagged "ENOTSUP" (so JS land can detect + polyfill) and return a pending
+// exception rather than silently failing. (ChakraCore added BigInt behind a flag, but the OS Chakra
+// this backend targets did not ship it.)
+static napi_status napi_bigint_not_supported(napi_env env) {
+  CHECK_ENV(env);
+  CHECK_NAPI(napi_throw_error(
+      env, "ENOTSUP",
+      "BigInt is not supported by the underlying JavaScript engine (Chakra)."));
+  return napi_set_last_error(env, napi_pending_exception);
+}
+
+napi_status napi_create_bigint_int64(napi_env env, int64_t value, napi_value* result) {
+  return napi_bigint_not_supported(env);
+}
+
+napi_status napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result) {
+  return napi_bigint_not_supported(env);
+}
+
+napi_status napi_create_bigint_words(napi_env env,
+                                     int sign_bit,
+                                     size_t word_count,
+                                     const uint64_t* words,
+                                     napi_value* result) {
+  return napi_bigint_not_supported(env);
+}
+
+napi_status napi_get_value_bigint_int64(napi_env env,
+                                        napi_value value,
+                                        int64_t* result,
+                                        bool* lossless) {
+  return napi_bigint_not_supported(env);
+}
+
+napi_status napi_get_value_bigint_uint64(napi_env env,
+                                         napi_value value,
+                                         uint64_t* result,
+                                         bool* lossless) {
+  return napi_bigint_not_supported(env);
+}
+
+napi_status napi_get_value_bigint_words(napi_env env,
+                                        napi_value value,
+                                        int* sign_bit,
+                                        size_t* word_count,
+                                        uint64_t* words) {
+  return napi_bigint_not_supported(env);
+}
+
 napi_status napi_add_finalizer(napi_env env,
                                napi_value js_object,
                                void* native_object,

Core/Node-API/Source/js_native_api_chakra.h

@@ -15,7 +15,19 @@ struct napi_env__ {
 
   JsPropertyIdRef wrap_property_id = JS_INVALID_REFERENCE;
 
+  // napi_set_instance_data / napi_get_instance_data (N-API v6).
+  void* instance_data = nullptr;
+  napi_finalize instance_data_finalize_cb = nullptr;
+  void* instance_data_finalize_hint = nullptr;
+
   const std::thread::id thread_id{std::this_thread::get_id()};
+
+  ~napi_env__() {
+    // Run the instance-data finalizer at env teardown (env_chakra.cc deletes the env), matching V8/JSC.
+    if (instance_data_finalize_cb != nullptr) {
+      instance_data_finalize_cb(this, instance_data, instance_data_finalize_hint);
+    }
+  }
 };
 
 #define RETURN_STATUS_IF_FALSE(env, condition, status) \