react-native-windows 0.71.35 → 0.71.37

package/Shared/JSI/NapiJsiV8RuntimeHolder.cpp

@@ -0,0 +1,209 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "NapiJsiV8RuntimeHolder.h"
+
+using namespace facebook::jsi;
+using namespace facebook::react;
+
+using std::shared_ptr;
+using std::unique_ptr;
+
+namespace Microsoft::JSI {
+
+class NapiTask {
+ public:
+  NapiTask(void *task, v8_task_run_cb onTaskRun, v8_task_release_cb onTaskRelease)
+      : task_(task), onTaskRun_(onTaskRun), onTaskRelease_(onTaskRelease) {}
+
+  NapiTask(NapiTask &&other)
+      : task_(std::exchange(other.task_, nullptr)),
+        onTaskRun_(std::exchange(other.onTaskRun_, nullptr)),
+        onTaskRelease_(std::exchange(other.onTaskRelease_, nullptr)) {}
+
+  NapiTask &operator=(NapiTask &&other) {
+    if (this != &other) {
+      NapiTask taskToDelete(std::move(*this));
+      task_ = std::exchange(other.task_, nullptr);
+      onTaskRun_ = std::exchange(other.onTaskRun_, nullptr);
+      onTaskRelease_ = std::exchange(other.onTaskRelease_, nullptr);
+    }
+    return *this;
+  }
+
+  NapiTask(const NapiTask &other) = delete;
+  NapiTask &operator=(const NapiTask &other) = delete;
+
+  ~NapiTask() {
+    if (task_ != nullptr) {
+      onTaskRelease_(task_);
+    }
+  }
+
+  void Run() const {
+    if (task_ != nullptr) {
+      onTaskRun_(task_);
+    }
+  }
+
+ private:
+  void *task_;
+  v8_task_run_cb onTaskRun_;
+  v8_task_release_cb onTaskRelease_;
+};
+
+class NapiTaskRunner {
+ public:
+  NapiTaskRunner(std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) : m_jsQueue(std::move(jsQueue)) {}
+
+  static v8_task_runner_t Create(std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) {
+    NapiTaskRunner *taskRunner = new NapiTaskRunner(std::move(jsQueue));
+    return v8_create_task_runner(reinterpret_cast<void *>(taskRunner), &PostTask, &Release);
+  }
+
+ private:
+  static void __cdecl PostTask(
+      void *taskRunner,
+      void *task,
+      v8_task_run_cb onTaskRun,
+      v8_task_release_cb onTaskRelease) {
+    auto napiTask = std::make_shared<NapiTask>(task, onTaskRun, onTaskRelease);
+    reinterpret_cast<NapiTaskRunner *>(taskRunner)->m_jsQueue->runOnQueue([napiTask = std::move(napiTask)] {
+      napiTask->Run();
+    });
+  }
+
+  static void __cdecl Release(void *taskRunner) {
+    delete reinterpret_cast<NapiTaskRunner *>(taskRunner);
+  }
+
+ private:
+  std::shared_ptr<facebook::react::MessageQueueThread> m_jsQueue;
+};
+
+NapiJsiV8RuntimeHolder::NapiJsiV8RuntimeHolder(
+    shared_ptr<DevSettings> devSettings,
+    shared_ptr<MessageQueueThread> jsQueue,
+    unique_ptr<ScriptStore> &&scriptStore,
+    unique_ptr<PreparedScriptStore> &&preparedScriptStore) noexcept
+    : m_useDirectDebugger{devSettings->useDirectDebugger},
+      m_debuggerBreakOnNextLine{devSettings->debuggerBreakOnNextLine},
+      m_debuggerPort{devSettings->debuggerPort},
+      m_debuggerRuntimeName{devSettings->debuggerRuntimeName},
+      m_jsQueue{jsQueue},
+      m_scriptStore{std::move(scriptStore)},
+      m_preparedScriptStore{std::move(preparedScriptStore)} {}
+
+void NapiJsiV8RuntimeHolder::InitRuntime() noexcept {
+  napi_ext_env_settings settings{};
+  settings.this_size = sizeof(settings);
+  if (m_debuggerPort > 0)
+    settings.inspector_port = m_debuggerPort;
+
+  settings.flags.enable_inspector = m_useDirectDebugger;
+  settings.flags.wait_for_debugger = m_debuggerBreakOnNextLine;
+  //  TODO: args.debuggerRuntimeName = debuggerRuntimeName_;
+  settings.foreground_task_runner = NapiTaskRunner::Create(m_jsQueue);
+
+  napi_ext_script_cache scriptCache = InitScriptCache(std::move(m_preparedScriptStore));
+  settings.script_cache = &scriptCache;
+
+  napi_env env{};
+  napi_ext_create_env(&settings, &env);
+  // Associate environment to holder.
+  napi_set_instance_data(env, this, nullptr /*finalize_cb*/, nullptr /*finalize_hint*/);
+
+  m_runtime = MakeNodeApiJsiRuntime(env);
+  m_ownThreadId = std::this_thread::get_id();
+}
+
+struct NodeApiJsiBuffer : facebook::jsi::Buffer {
+  static std::shared_ptr<const facebook::jsi::Buffer> CreateJsiBuffer(const napi_ext_buffer *buffer) {
+    if (buffer && buffer->data) {
+      return std::shared_ptr<const facebook::jsi::Buffer>(new NodeApiJsiBuffer(buffer));
+    } else {
+      return {};
+    }
+  }
+
+  NodeApiJsiBuffer(const napi_ext_buffer *buffer) noexcept : buffer_(*buffer) {}
+
+  ~NodeApiJsiBuffer() override {
+    if (buffer_.buffer_object.finalize_cb) {
+      buffer_.buffer_object.finalize_cb(nullptr, buffer_.buffer_object.data, buffer_.buffer_object.finalize_hint);
+    }
+  }
+
+  const uint8_t *data() const override {
+    return buffer_.data;
+  }
+
+  size_t size() const override {
+    return buffer_.byte_size;
+  }
+
+ private:
+  napi_ext_buffer buffer_;
+};
+
+napi_ext_script_cache NapiJsiV8RuntimeHolder::InitScriptCache(
+    unique_ptr<PreparedScriptStore> &&preparedScriptStore) noexcept {
+  napi_ext_script_cache scriptCache{};
+  scriptCache.cache_object = NativeObjectWrapper<unique_ptr<PreparedScriptStore>>::Wrap(std::move(preparedScriptStore));
+  scriptCache.load_cached_script = [](napi_env env,
+                                      napi_ext_script_cache *script_cache,
+                                      napi_ext_cached_script_metadata *script_metadata,
+                                      napi_ext_buffer *result) -> napi_status {
+    PreparedScriptStore *scriptStore = reinterpret_cast<PreparedScriptStore *>(script_cache->cache_object.data);
+    std::shared_ptr<const facebook::jsi::Buffer> buffer = scriptStore->tryGetPreparedScript(
+        ScriptSignature{script_metadata->source_url, script_metadata->source_hash},
+        JSRuntimeSignature{script_metadata->runtime_name, script_metadata->runtime_version},
+        script_metadata->tag);
+    if (buffer) {
+      result->buffer_object = NativeObjectWrapper<std::shared_ptr<const facebook::jsi::Buffer>>::Wrap(
+          std::shared_ptr<const facebook::jsi::Buffer>{buffer});
+      result->data = buffer->data();
+      result->byte_size = buffer->size();
+    } else {
+      *result = napi_ext_buffer{};
+    }
+    return napi_ok;
+  };
+  scriptCache.store_cached_script = [](napi_env env,
+                                       napi_ext_script_cache *script_cache,
+                                       napi_ext_cached_script_metadata *script_metadata,
+                                       const napi_ext_buffer *buffer) -> napi_status {
+    PreparedScriptStore *scriptStore = reinterpret_cast<PreparedScriptStore *>(script_cache->cache_object.data);
+    scriptStore->persistPreparedScript(
+        NodeApiJsiBuffer::CreateJsiBuffer(buffer),
+        ScriptSignature{script_metadata->source_url, script_metadata->source_hash},
+        JSRuntimeSignature{script_metadata->runtime_name, script_metadata->runtime_version},
+        script_metadata->tag);
+    return napi_ok;
+  };
+  return scriptCache;
+}
+
+#pragma region Microsoft::JSI::RuntimeHolderLazyInit
+
+facebook::react::JSIEngineOverride NapiJsiV8RuntimeHolder::getRuntimeType() noexcept {
+  return facebook::react::JSIEngineOverride::V8NodeApi;
+}
+
+shared_ptr<Runtime> NapiJsiV8RuntimeHolder::getRuntime() noexcept /*override*/
+{
+  std::call_once(m_onceFlag, [this]() { InitRuntime(); });
+
+  if (!m_runtime)
+    std::terminate();
+
+  // V8 NapiJsiRuntime is not known to be thread safe.
+  if (m_ownThreadId != std::this_thread::get_id())
+    __fastfail(FAST_FAIL_INVALID_THREAD);
+
+  return m_runtime;
+}
+
+#pragma endregion Microsoft::JSI::RuntimeHolderLazyInit
+
+} // namespace Microsoft::JSI

package/Shared/JSI/NapiJsiV8RuntimeHolder.h

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <DevSettings.h>
+#include <JSI/NodeApiJsiRuntime.h>
+#include "RuntimeHolder.h"
+#include "ScriptStore.h"
+
+namespace Microsoft::JSI {
+
+class NapiJsiV8RuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
+ public:
+  std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept override;
+  facebook::react::JSIEngineOverride getRuntimeType() noexcept override;
+
+  NapiJsiV8RuntimeHolder(
+      std::shared_ptr<facebook::react::DevSettings> devSettings,
+      std::shared_ptr<facebook::react::MessageQueueThread> jsQueue,
+      std::unique_ptr<facebook::jsi::ScriptStore> &&scriptStore,
+      std::unique_ptr<facebook::jsi::PreparedScriptStore> &&preparedScriptStore) noexcept;
+
+ private:
+  void InitRuntime() noexcept;
+  napi_ext_script_cache InitScriptCache(
+      std::unique_ptr<facebook::jsi::PreparedScriptStore> &&preparedScriptStore) noexcept;
+
+  std::shared_ptr<facebook::jsi::Runtime> m_runtime;
+  std::shared_ptr<facebook::react::MessageQueueThread> m_jsQueue;
+
+  std::unique_ptr<facebook::jsi::ScriptStore> m_scriptStore;
+  std::unique_ptr<facebook::jsi::PreparedScriptStore> m_preparedScriptStore;
+
+  std::once_flag m_onceFlag;
+  std::thread::id m_ownThreadId;
+
+  uint16_t m_debuggerPort;
+  bool m_useDirectDebugger{false};
+  bool m_debuggerBreakOnNextLine{false};
+  std::string m_debuggerRuntimeName;
+};
+
+} // namespace Microsoft::JSI

package/Shared/JSI/RuntimeHolder.h

@@ -11,7 +11,7 @@ namespace Microsoft::JSI {
 // a. lazily create a JSI Runtime on the first call to getRuntime
 // b. subsequent calls to getRuntime should return the Runtime created in (a)
 
-// Note: all calls to getRuntime() should happen on the same thread unless you are sure that
+// Note :: All calls to getRuntime() should happen on the same thread unless you are sure that
 // the underlying Runtime instance is thread safe.
 
 struct RuntimeHolderLazyInit {
@@ -21,7 +21,7 @@ struct RuntimeHolderLazyInit {
   virtual void teardown() noexcept {};
 
   // You can call this when a crash happens to attempt recording additional data
-  // The fileDescriptor supplied is a raw file stream an implementation might write JSON to.
+  // The fd supplied is a raw file stream an implementation might write JSON to
   virtual void crashHandler(int fileDescriptor) noexcept {};
 };
 

package/Shared/JSI/ScriptStore.h

@@ -5,11 +5,12 @@
 #include <jsi/jsi.h>
 #include <memory>
 
-namespace facebook::jsi {
+namespace facebook {
+namespace jsi {
 
-// Integer type as it's persist friendly.
-using ScriptVersion_t = uint64_t; // It should be std::optional<uint64_t> once we have c++17 available everywhere.
-                                  // Until then, 0 implies versioning not available.
+// Integer type as it's persist friently.
+using ScriptVersion_t = uint64_t; // It shouldbe std::optional<uint64_t> once we have c++17 available everywhere. Until
+                                  // then, 0 implies versioning not available.
 using JSRuntimeVersion_t = uint64_t; // 0 implies version can't be computed. We assert whenever that happens.
 
 struct VersionedBuffer {
@@ -29,14 +30,14 @@ struct JSRuntimeSignature {
 
 // Most JSI::Runtime implementation offer some form of prepared JavaScript which offers better performance
 // characteristics when loading comparing to plain JavaScript. Embedders can provide an instance of this interface
-// (through JSI::Runtime implementation's factory method), to enable persistence of the prepared script
-// and retrieval on subsequent evaluation of a script.
+// (through JSI::Runtime implementation's factory method), to enable persistance of the prepared script and retrieval on
+// subsequent evaluation of a script.
 struct PreparedScriptStore {
   virtual ~PreparedScriptStore() = default;
 
-  // Try to retrieve the prepared JavaScript for a given combination of script & runtime.
-  // scriptSignature : JavaScript URL and version
-  // RuntimeSignature : JavaScript engine type and version
+  // Try to retrieve the prepared javascript for a given combination of script & runtime.
+  // scriptSignature : Javascript url and version
+  // RuntimeSignature : Javascript engine type and version
   // prepareTag : Custom tag to uniquely identify JS engine specific preparation schemes. It is usually useful while
   // experimentation and can be null. It is possible that no prepared script is available for a given script & runtime
   // signature. This method should null if so
@@ -46,12 +47,12 @@ struct PreparedScriptStore {
       const char *prepareTag // Optional tag. For e.g. eagerly evaluated vs lazy cache.
       ) noexcept = 0;
 
-  // Persist the prepared JavaScript for a given combination of script & runtime.
-  // scriptSignature : JavaScript URL and version
-  // RuntimeSignature : JavaScript engine type and version
+  // Persist the perpared javascript for a given combination of script & runtime.
+  // scriptSignature : Javascript url and version
+  // RuntimeSignature : Javascript engine type and version
   // prepareTag : Custom tag to uniquely identify JS engine specific preparation schemes. It is usually useful while
   // experimentation and can be null. It is possible that no prepared script is available for a given script & runtime
-  // signature. This method should null if so Any failure in persistence should be identified during the subsequent
+  // signature. This method should null if so Any failure in persistance should be identified during the subsequent
   // retrieval through the integrity mechanism which must be put into the storage.
   virtual void persistPreparedScript(
       std::shared_ptr<const facebook::jsi::Buffer> preparedScript,
@@ -62,16 +63,17 @@ struct PreparedScriptStore {
 };
 
 // JSI::Runtime implementation must be provided an instance on this interface to enable version sensitive capabilities
-// such as usage of prepared JavaScript script. Alternatively, this entity can be used to directly provide the
-// JavaScript buffer and rich meta data to the JSI::Runtime instance.
+// such as usage of pre-prepared javascript script. Alternatively, this entity can be used to directly provide the
+// Javascript buffer and rich metadata to the JSI::Runtime instance.
 struct ScriptStore {
   virtual ~ScriptStore() = default;
 
-  // Return the JavaScript buffer and version corresponding to a given URL.
+  // Return the Javascript buffer and version corresponding to a given url.
   virtual VersionedBuffer getVersionedScript(const std::string &url) noexcept = 0;
 
-  // Return the version of the JavaScript buffer corresponding to a given URL.
+  // Return the version of the Javascript buffer corresponding to a given url.
   virtual ScriptVersion_t getScriptVersion(const std::string &url) noexcept = 0;
 };
 
-} // namespace facebook::jsi
+} // namespace jsi
+} // namespace facebook

package/Shared/OInstance.cpp

@@ -51,11 +51,13 @@
 #include "HermesRuntimeHolder.h"
 
 #if defined(USE_V8)
-#include <JSI/V8RuntimeHolder.h>
+#include <JSI/NapiJsiV8RuntimeHolder.h>
+
+#include "BaseScriptStoreImpl.h"
+#include "V8JSIRuntimeHolder.h"
 #endif
 #include <ReactCommon/CallInvoker.h>
 #include <ReactCommon/TurboModuleBinding.h>
-#include "BaseScriptStoreImpl.h"
 #include "ChakraRuntimeHolder.h"
 
 #include <tracing/tracing.h>
@@ -306,32 +308,46 @@ InstanceImpl::InstanceImpl(
     } else {
       assert(m_devSettings->jsiEngineOverride != JSIEngineOverride::Default);
       switch (m_devSettings->jsiEngineOverride) {
-        case JSIEngineOverride::Hermes: {
-          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
+        case JSIEngineOverride::Hermes:
+          m_devSettings->jsiRuntimeHolder = std::make_shared<HermesRuntimeHolder>(m_devSettings, m_jsThread);
+          break;
+        case JSIEngineOverride::V8: {
+#if defined(USE_V8)
+          std::unique_ptr<facebook::jsi::ScriptStore> scriptStore = nullptr;
+          std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore = nullptr;
 
-          wchar_t tempPath[MAX_PATH];
-          if (GetTempPathW(MAX_PATH, tempPath)) {
-            preparedScriptStore =
-                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
+          char tempPath[MAX_PATH];
+          if (GetTempPathA(MAX_PATH, tempPath)) {
+            preparedScriptStore = std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(tempPath);
           }
 
-          m_devSettings->jsiRuntimeHolder = std::make_shared<Microsoft::ReactNative::HermesRuntimeHolder>(
-              m_devSettings, m_jsThread, std::move(preparedScriptStore));
+          m_devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
+              m_devSettings, m_jsThread, std::move(scriptStore), std::move(preparedScriptStore));
           break;
+#else
+          assert(false); // V8 is not available in this build, fallthrough
+          [[fallthrough]];
+#endif
         }
-        case JSIEngineOverride::V8:
         case JSIEngineOverride::V8NodeApi: {
 #if defined(USE_V8)
-          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
+          std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
 
           wchar_t tempPath[MAX_PATH];
-          if (GetTempPathW(MAX_PATH, tempPath)) {
+          if (GetTempPathW(static_cast<DWORD>(std::size(tempPath)), tempPath)) {
             preparedScriptStore =
-                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
+                std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
+          }
+
+          if (!preparedScriptStore) {
+            if (m_devSettings->errorCallback)
+              m_devSettings->errorCallback("Could not initialize prepared script store");
+
+            break;
           }
 
-          m_devSettings->jsiRuntimeHolder = make_shared<Microsoft::ReactNative::V8RuntimeHolder>(
-              m_devSettings, m_jsThread, std::move(preparedScriptStore), false);
+          m_devSettings->jsiRuntimeHolder = make_shared<NapiJsiV8RuntimeHolder>(
+              m_devSettings, m_jsThread, nullptr /*scriptStore*/, std::move(preparedScriptStore));
           break;
 #else
           if (m_devSettings->errorCallback)
@@ -538,35 +554,34 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
   // If this code is enabled, we will have unused module instances.
   // Also, MSRN has a different property bag mechanism incompatible with this method's transitionalProps variable.
 #if (defined(_MSC_VER) && !defined(WINRT))
-  modules.push_back(std::make_unique<CxxNativeModule>(
-      m_innerInstance,
-      Microsoft::React::GetHttpModuleName(),
-      [nativeQueue, transitionalProps]() -> std::unique_ptr<xplat::module::CxxModule> {
-        return Microsoft::React::CreateHttpModule(transitionalProps);
-      },
-      nativeQueue));
-
-  modules.push_back(std::make_unique<CxxNativeModule>(
-      m_innerInstance,
-      Microsoft::React::GetWebSocketModuleName(),
-      [nativeQueue, transitionalProps]() -> std::unique_ptr<xplat::module::CxxModule> {
-        return Microsoft::React::CreateWebSocketModule(transitionalProps);
-      },
-      nativeQueue));
-
-  // Use in case the host app provides its a non-Blob-compatilbe HTTP module.
-  if (!Microsoft::React::GetRuntimeOptionBool("Blob.DisableModule")) {
+  // Applications using the Windows ABI feature should loade the networking TurboModule variants instead.
+  if (!m_devSettings->omitNetworkingCxxModules) {
     modules.push_back(std::make_unique<CxxNativeModule>(
         m_innerInstance,
-        Microsoft::React::GetBlobModuleName(),
-        [transitionalProps]() { return Microsoft::React::CreateBlobModule(transitionalProps); },
+        Microsoft::React::GetWebSocketModuleName(),
+        [transitionalProps]() { return Microsoft::React::CreateWebSocketModule(transitionalProps); },
         nativeQueue));
 
-    modules.push_back(std::make_unique<CxxNativeModule>(
-        m_innerInstance,
-        Microsoft::React::GetFileReaderModuleName(),
-        [transitionalProps]() { return Microsoft::React::CreateFileReaderModule(transitionalProps); },
-        nativeQueue));
+    // Use in case the host app provides its a non-Blob-compatilbe HTTP module.
+    if (!Microsoft::React::GetRuntimeOptionBool("Blob.DisableModule")) {
+      modules.push_back(std::make_unique<CxxNativeModule>(
+          m_innerInstance,
+          Microsoft::React::GetHttpModuleName(),
+          [transitionalProps]() { return Microsoft::React::CreateHttpModule(transitionalProps); },
+          nativeQueue));
+
+      modules.push_back(std::make_unique<CxxNativeModule>(
+          m_innerInstance,
+          Microsoft::React::GetBlobModuleName(),
+          [transitionalProps]() { return Microsoft::React::CreateBlobModule(transitionalProps); },
+          nativeQueue));
+
+      modules.push_back(std::make_unique<CxxNativeModule>(
+          m_innerInstance,
+          Microsoft::React::GetFileReaderModuleName(),
+          [transitionalProps]() { return Microsoft::React::CreateFileReaderModule(transitionalProps); },
+          nativeQueue));
+    }
   }
 
   modules.push_back(std::make_unique<CxxNativeModule>(

package/Shared/Shared.vcxitems

@@ -29,13 +29,14 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)Hasher.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)HermesRuntimeHolder.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)HermesSamplingProfiler.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)HermesShim.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)InspectorPackagerConnection.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)InstanceManager.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)JSBigAbiString.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)JSI\ChakraApi.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)JSI\ChakraJsiRuntime_edgemode.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)JSI\ChakraRuntime.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)JSI\V8RuntimeHolder.cpp">
+    <ClCompile Include="$(MSBuildThisFileDirectory)JSI\NapiJsiV8RuntimeHolder.cpp">
       <ExcludedFromBuild Condition="'$(UseV8)' != 'true'">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="$(MSBuildThisFileDirectory)LayoutAnimation.cpp" />
@@ -66,7 +67,6 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)OInstance.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)PackagerConnection.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)RuntimeOptions.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)SafeLoadLibrary.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Threading\BatchingQueueThread.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Threading\MessageDispatchQueue.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Threading\MessageQueueThreadFactory.cpp" />
@@ -74,10 +74,12 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)TurboModuleManager.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Utils.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Utils\WinRTConversions.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)V8JSIRuntimeHolder.cpp">
+      <ExcludedFromBuild Condition="'$(UseV8)' != 'true'">true</ExcludedFromBuild>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="$(MSBuildThisFileDirectory)..\include\Shared\cdebug.h" />
-    <ClInclude Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\JsiApi.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)AbiSafe.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)AsyncStorageModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)AsyncStorage\AsyncStorageManager.h" />
@@ -86,6 +88,7 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)BaseFileReaderResource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)CppRuntimeOptions.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)HermesSamplingProfiler.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)HermesShim.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)IBlobPersistor.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)IFileReaderResource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\ByteArrayBuffer.h" />
@@ -93,7 +96,7 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\ChakraRuntime.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\ChakraRuntimeArgs.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\ChakraRuntimeFactory.h" />
-    <ClInclude Include="$(MSBuildThisFileDirectory)JSI\V8RuntimeHolder.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)JSI\NapiJsiV8RuntimeHolder.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\RuntimeHolder.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\ScriptStore.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\BlobModule.h" />
@@ -150,7 +153,6 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)NativeModuleProvider.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)OInstance.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Pch\pch.h" />
-    <ClInclude Include="$(MSBuildThisFileDirectory)SafeLoadLibrary.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)ShadowNode.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)ShadowNodeRegistry.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)targetver.h" />
@@ -165,6 +167,7 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)Utils.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Utils\CppWinrtLessExceptions.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Utils\WinRTConversions.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)V8JSIRuntimeHolder.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)WebSocketJSExecutorFactory.h" />
     <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Modules\ReactRootViewTagGenerator.cpp" />
     <ClCompile Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Utils\ImageUtils.cpp" />
@@ -311,18 +314,4 @@
       <SubType>Code</SubType>
     </ClCompile>
   </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="$(NodeApiJsiDir)src\ApiLoaders\HermesApi.h" />
-    <ClInclude Include="$(NodeApiJsiDir)src\ApiLoaders\HermesApi.inc" />
-    <ClCompile Include="$(NodeApiJsiDir)src\ApiLoaders\HermesApi.cpp">
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup Condition="'$(UseV8)' == 'true'">
-    <ClInclude Include="$(NodeApiJsiDir)src\ApiLoaders\V8Api.h" />
-    <ClInclude Include="$(NodeApiJsiDir)src\ApiLoaders\V8Api.inc" />
-    <ClCompile Include="$(NodeApiJsiDir)src\ApiLoaders\V8Api.cpp">
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-    </ClCompile>
-  </ItemGroup>
 </Project>