react-native-windows 0.71.25 → 0.71.27

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/Modules/HttpModule.cpp

@@ -237,6 +237,8 @@ std::map<string, dynamic> HttpModule::getConstants() {
 
 // clang-format off
 std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods() {
+  // See CxxNativeModule::lazyInit()
+  SetUpHttpResource(m_resource, getInstance(), m_inspectableProperties);
 
   return
   {
@@ -249,12 +251,6 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
           return;
         }
 
-        auto resource = holder->Module->m_resource;
-        if (!holder->Module->m_isResourceSetup)
-        {
-          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
-          holder->Module->m_isResourceSetup = true;
-        }
         holder->Module->m_requestId++;
 
         auto params = facebook::xplat::jsArgAsObject(args, 0);
@@ -263,7 +259,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
           headers.emplace(header.first.getString(), header.second.getString());
         }
 
-        resource->SendRequest(
+        holder->Module->m_resource->SendRequest(
           params["method"].asString(),
           params["url"].asString(),
           holder->Module->m_requestId,
@@ -289,14 +285,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
           return;
         }
 
-        auto resource = holder->Module->m_resource;
-        if (!holder->Module->m_isResourceSetup)
-        {
-          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
-          holder->Module->m_isResourceSetup = true;
-        }
-
-        resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
+        holder->Module->m_resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
       }
     },
     {
@@ -309,14 +298,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
           return;
         }
 
-        auto resource = holder->Module->m_resource;
-        if (!holder->Module->m_isResourceSetup)
-        {
-          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
-          holder->Module->m_isResourceSetup = true;
-        }
-
-        resource->ClearCookies();
+        holder->Module->m_resource->ClearCookies();
       }
     }
   };
@@ -331,6 +313,11 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
   return s_moduleName;
 }
 
+/*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule(
+    IInspectable const &inspectableProperties) noexcept {
+  return std::make_unique<HttpModule>(inspectableProperties);
+}
+
 /*extern*/ const wchar_t *GetHttpTurboModuleName() noexcept {
   return s_moduleNameW;
 }

package/Shared/Modules/HttpModule.h

@@ -84,7 +84,6 @@ class HttpModule : public facebook::xplat::module::CxxModule {
 
   std::shared_ptr<Networking::IHttpResource> m_resource;
   std::shared_ptr<ModuleHolder> m_holder;
-  bool m_isResourceSetup{false};
   int64_t m_requestId{0};
 
   // Property bag high level reference.

package/Shared/Networking/DefaultBlobResource.cpp

@@ -145,8 +145,13 @@ void DefaultBlobResource::AddNetworkingHandler() noexcept /*override*/ {
       httpHandler->AddRequestBodyHandler(m_requestBodyHandler);
       httpHandler->AddResponseHandler(m_responseHandler);
     }
+  } else {
+    // #11439 - The absence of HttpModule.Proxy may be caused by a module initialization race condition.
+    // Best-effort approach to set up the request/response handlers by exposing this interface to dependents
+    // (i.e. IHttpResource).
+    auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IBlobResource>>>{L"Blob.Resource"};
+    m_propertyBag.Set(propId, weak_ptr<IBlobResource>(shared_from_this()));
   }
-  // TODO: else emit error?
 }
 
 void DefaultBlobResource::AddWebSocketHandler(int64_t id) noexcept /*override*/ {

package/Shared/Networking/WinRTHttpResource.cpp

@@ -6,6 +6,7 @@
 #include "WinRTHttpResource.h"
 
 #include <CppRuntimeOptions.h>
+#include <Networking/IBlobResource.h>
 #include <ReactPropertyBag.h>
 #include <Utils/CppWinrtLessExceptions.h>
 #include <Utils/WinRTConversions.h>
@@ -672,6 +673,14 @@ void WinRTHttpResource::AddResponseHandler(shared_ptr<IResponseHandler> response
     auto propBag = ReactPropertyBag{inspectableProperties.try_as<IReactPropertyBag>()};
     auto moduleProxy = weak_ptr<IHttpModuleProxy>{result};
     propBag.Set(propId, std::move(moduleProxy));
+
+    // #11439 - Best-effort attempt to set up the HTTP handler after an initial call to addNetworkingHandler failed.
+    auto blobRcPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<Networking::IBlobResource>>>{L"Blob.Resource"};
+    if (auto prop = propBag.Get(blobRcPropId)) {
+      if (auto blobRc = prop.Value().lock()) {
+        blobRc->AddNetworkingHandler();
+      }
+    }
   }
 
   return result;

package/Shared/OInstance.cpp

@@ -26,7 +26,6 @@
 #include <cxxreact/ModuleRegistry.h>
 
 #include <Modules/ExceptionsManagerModule.h>
-#include <Modules/HttpModule.h>
 #include <Modules/PlatformConstantsModule.h>
 #include <Modules/SourceCodeModule.h>
 #include <Modules/StatusBarManagerModule.h>
@@ -52,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>
@@ -68,15 +69,6 @@ using namespace Microsoft::JSI;
 using std::make_shared;
 using winrt::Microsoft::ReactNative::ReactPropertyBagHelper;
 
-namespace Microsoft::React {
-
-/*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule(
-    winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept {
-  return std::make_unique<HttpModule>(inspectableProperties);
-}
-
-} // namespace Microsoft::React
-
 namespace facebook {
 namespace react {
 
@@ -316,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));
           }
 
-          m_devSettings->jsiRuntimeHolder = make_shared<Microsoft::ReactNative::V8RuntimeHolder>(
-              m_devSettings, m_jsThread, std::move(preparedScriptStore), false);
+          if (!preparedScriptStore) {
+            if (m_devSettings->errorCallback)
+              m_devSettings->errorCallback("Could not initialize prepared script store");
+
+            break;
+          }
+
+          m_devSettings->jsiRuntimeHolder = make_shared<NapiJsiV8RuntimeHolder>(
+              m_devSettings, m_jsThread, nullptr /*scriptStore*/, std::move(preparedScriptStore));
           break;
 #else
           if (m_devSettings->errorCallback)
@@ -543,6 +549,10 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
   std::vector<std::unique_ptr<NativeModule>> modules;
   auto transitionalProps{ReactPropertyBagHelper::CreatePropertyBag()};
 
+  // These modules are instantiated separately in MSRN (Universal Windows).
+  // When there are module name collisions, the last one registered is used.
+  // 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,
@@ -551,7 +561,6 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
         return Microsoft::React::CreateHttpModule(transitionalProps);
       },
       nativeQueue));
-#endif
 
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
@@ -561,11 +570,18 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
       },
       nativeQueue));
 
-  // TODO: This is not included for UWP because we have a different module which
-  // is added later. However, this one is designed
-  //  so that we can base a UWP version on it. We need to do that but is not high
-  //  priority.
-#if (defined(_MSC_VER) && !defined(WINRT))
+  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>(
       m_innerInstance,
       "Timing",
@@ -620,26 +636,6 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
       []() { return std::make_unique<StatusBarManagerModule>(); },
       nativeQueue));
 
-  // These modules are instantiated separately in MSRN (Universal Windows).
-  // When there are module name collisions, the last one registered is used.
-  // 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))
-  if (Microsoft::React::GetRuntimeOptionBool("Blob.EnableModule")) {
-    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));
-  }
-#endif
-
   return modules;
 }