react-native-windows 0.81.1 → 0.82.0-preview.1

package/Shared/OInstance.cpp

@@ -2,34 +2,23 @@
 // Licensed under the MIT License.
 
 #include "pch.h"
-
-#include <cxxreact/CxxModule.h>
-#include <cxxreact/CxxNativeModule.h>
-#include <cxxreact/Instance.h>
+#include "OInstance.h"
 #include <cxxreact/JSBigString.h>
-#include <cxxreact/JSExecutor.h>
 #include <cxxreact/JsBundleType.h>
-#include <cxxreact/ReactMarker.h>
 #include <folly/Bits.h>
 #include <folly/json.h>
 #include <jsi/jsi.h>
-#include <jsireact/JSIExecutor.h>
 #include <filesystem>
-#include "OInstance.h"
 #include "Unicode.h"
 
-#include "Chakra/ChakraHelpers.h"
-#include "Chakra/ChakraUtils.h"
 #include "JSI/RuntimeHolder.h"
 
 #include <cxxreact/MessageQueueThread.h>
-#include <cxxreact/ModuleRegistry.h>
 
 #if (defined(_MSC_VER) && (defined(WINRT)))
 #include <Utils/LocalBundleReader.h>
 #endif
 
-#include <BatchingMessageQueueThread.h>
 #include <CppRuntimeOptions.h>
 #include <CreateModules.h>
 #include <DevSettings.h>
@@ -38,13 +27,13 @@
 #include <ReactPropertyBag.h>
 #include <SchedulerSettings.h>
 #include <Shlwapi.h>
-#include <WebSocketJSExecutorFactory.h>
 #include <safeint.h>
+#include <werapi.h>
 #include "Inspector/ReactInspectorThread.h"
 #include "PackagerConnection.h"
 #include "Threading/MessageDispatchQueue.h"
 
-#if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
+#if defined(ENABLE_DEVSERVER_HBCBUNDLES)
 #include <hermes/BytecodeVersion.h>
 #endif
 #include "HermesRuntimeHolder.h"
@@ -59,7 +48,6 @@
 #include <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.h>
 #include "BaseScriptStoreImpl.h"
-#include "ChakraRuntimeHolder.h"
 
 #include <tracing/tracing.h>
 namespace fs = std::filesystem;
@@ -70,6 +58,16 @@ using namespace Microsoft::JSI;
 using std::make_shared;
 using winrt::Microsoft::ReactNative::ReactPropertyBagHelper;
 
+namespace {
+
+uint32_t getPageSize() noexcept {
+  SYSTEM_INFO systemInfo;
+  GetSystemInfo(&systemInfo);
+  return systemInfo.dwPageSize;
+}
+
+} // namespace
+
 namespace Microsoft::ReactNative {
 
 // Note: Based on
@@ -98,7 +96,7 @@ void LoadRemoteUrlScript(
   // errors before attempting to load the actual script.
 
   uint32_t hermesBytecodeVersion = 0;
-#if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
+#if defined(ENABLE_DEVSERVER_HBCBUNDLES)
   hermesBytecodeVersion = ::hermes::hbc::BYTECODE_VERSION;
 #endif
 
@@ -176,457 +174,179 @@ void LoadRemoteUrlScript(
 #undef __SAFEADD__
   } else {
     // Remote debug executor loads script from a Uri, rather than taking the actual bundle string
-    fnLoadScriptCallback(
-        std::make_unique<const facebook::react::JSBigStdString>(
-            devSettings->useWebDebugger ? bundleUrl : jsBundleString),
-        bundleUrl);
-  }
-}
-
-std::unique_ptr<const facebook::react::JSBigString> JsBigStringFromPath(
-    std::shared_ptr<facebook::react::DevSettings> devSettings,
-    const std::string &jsBundleRelativePath) noexcept {
-#if (defined(_MSC_VER) && !defined(WINRT))
-  std::wstring bundlePath = (fs::u8path(devSettings->bundleRootPath) / jsBundleRelativePath).wstring();
-  return facebook::react::FileMappingBigString::fromPath(bundlePath);
-#else
-  std::wstring bundlePath;
-  if (devSettings->bundleRootPath.starts_with("resource://")) {
-    auto uri = winrt::Windows::Foundation::Uri(
-        winrt::to_hstring(devSettings->bundleRootPath), winrt::to_hstring(jsBundleRelativePath));
-    bundlePath = uri.ToString();
-  } else {
-    bundlePath = (fs::u8path(devSettings->bundleRootPath) / (jsBundleRelativePath + ".bundle")).wstring();
+    fnLoadScriptCallback(std::make_unique<const facebook::react::JSBigStdString>(jsBundleString), bundleUrl);
   }
-
-  return std::make_unique<::Microsoft::ReactNative::StorageFileBigString>(bundlePath);
-#endif
 }
 
-} // namespace Microsoft::ReactNative
+// We only support files whose size can fit within an uint32_t. Memory
+// mapping an empty or a larger file fails. If the file contents are not
+// null-terminated, file is copied into a dynamically  allocated,
+// page-file backed,  null-terminated buffer
+class FileMappingBigString : public facebook::react::JSBigString {
+ public:
+  FileMappingBigString(const std::wstring &filename, uint32_t offset = 0);
 
-namespace facebook::react {
+  bool isAscii() const override {
+    return false;
+  }
 
-namespace {
+  const char *c_str() const override {
+    return m_data.get();
+  }
 
-// OJSIExecutor is needed to override getRuntimeTargetDelegate to support the modern JSI inspector.
-class OJSIExecutor : public JSIExecutor {
- public:
-  OJSIExecutor(
-      std::shared_ptr<jsi::Runtime> runtime,
-      std::shared_ptr<ExecutorDelegate> delegate,
-      const JSIScopedTimeoutInvoker &timeoutInvoker,
-      RuntimeInstaller runtimeInstaller,
-      std::shared_ptr<facebook::react::jsinspector_modern::RuntimeTargetDelegate> &&targetDelegate) noexcept
-      : JSIExecutor(std::move(runtime), std::move(delegate), timeoutInvoker, std::move(runtimeInstaller)),
-        targetDelegate_(std::move(targetDelegate)) {}
-  jsinspector_modern::RuntimeTargetDelegate &getRuntimeTargetDelegate() override {
-    if (!targetDelegate_) {
-      // Use the fallback implementation from JSIExecutor.
-      return JSIExecutor::getRuntimeTargetDelegate();
-    }
-    return *targetDelegate_;
+  size_t size() const override {
+    return m_size;
   }
 
- private:
-  std::shared_ptr<facebook::react::jsinspector_modern::RuntimeTargetDelegate> targetDelegate_;
-};
+  // Returns nullptr when memory mapping failed
+  void *file_data() const {
+    return m_fileData.get();
+  }
 
-class OJSIExecutorFactory : public JSExecutorFactory {
- public:
-  std::unique_ptr<JSExecutor> createJSExecutor(
-      std::shared_ptr<ExecutorDelegate> delegate,
-      std::shared_ptr<MessageQueueThread> jsQueue) override {
-    Logger logger;
-    if (loggingHook_) {
-      // TODO :: Ensure the logLevels are mapped properly.
-      logger = [loggingHook = std::move(loggingHook_)](const std::string &message, unsigned int logLevel) {
-        loggingHook(static_cast<RCTLogLevel>(logLevel), message.c_str());
-      };
-    } else {
-      logger = [loggingHook = std::move(loggingHook_)](const std::string & /*message*/, unsigned int /*logLevel*/) {};
-    }
-    bindNativeLogger(*runtimeHolder_->getRuntime(), logger);
-
-    return std::make_unique<OJSIExecutor>(
-        runtimeHolder_->getRuntime(),
-        std::move(delegate),
-        JSIExecutor::defaultTimeoutInvoker,
-        [isProfiling = isProfilingEnabled_]([[maybe_unused]] jsi::Runtime &runtime) {
-#ifdef ENABLE_JS_SYSTRACE_TO_ETW
-          facebook::react::tracing::initializeJSHooks(runtime, isProfiling);
-#endif
-        },
-        runtimeHolder_->createRuntimeTargetDelegate());
+  // Returns zero when memory mapping failed
+  uint32_t file_size() const {
+    return m_fileSize;
   }
 
-  OJSIExecutorFactory(
-      std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> runtimeHolder,
-      NativeLoggingHook loggingHook,
-      bool isProfilingEnabled) noexcept
-      : runtimeHolder_{std::move(runtimeHolder)},
-        loggingHook_{std::move(loggingHook)},
-        isProfilingEnabled_{isProfilingEnabled} {}
+  static std::unique_ptr<const FileMappingBigString> fromPath(const std::wstring &filename);
 
  private:
-  std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> runtimeHolder_;
-  NativeLoggingHook loggingHook_;
-  bool isProfilingEnabled_;
-};
-
-} // namespace
-
-void logMarker(const facebook::react::ReactMarker::ReactMarkerId /*id*/, const char * /*tag*/) {}
-
-/*static*/ std::shared_ptr<InstanceImpl> InstanceImpl::MakeNoBundle(
-    std::shared_ptr<Instance> &&instance,
-    std::string &&jsBundleBasePath,
-    std::vector<
-        std::tuple<std::string, facebook::xplat::module::CxxModule::Provider, std::shared_ptr<MessageQueueThread>>>
-        &&cxxModules,
-    std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
-    std::shared_ptr<facebook::react::LongLivedObjectCollection> longLivedObjectCollection,
-    const winrt::Microsoft::ReactNative::IReactPropertyBag &propertyBag,
-    std::unique_ptr<InstanceCallback> &&callback,
-    std::shared_ptr<MessageQueueThread> jsQueue,
-    std::shared_ptr<MessageQueueThread> nativeQueue,
-    std::shared_ptr<DevSettings> devSettings,
-    std::shared_ptr<IDevSupportManager> devManager) noexcept {
-  auto inner = std::shared_ptr<InstanceImpl>(new InstanceImpl(
-      std::move(instance),
-      std::move(jsBundleBasePath),
-      std::move(cxxModules),
-      std::move(turboModuleRegistry),
-      std::move(longLivedObjectCollection),
-      propertyBag,
-      std::move(callback),
-      std::move(jsQueue),
-      std::move(nativeQueue),
-      std::move(devSettings),
-      std::move(devManager)));
-
-  inner->RegisterForReloadIfNecessary();
-
-  return inner;
-}
-
-/*static*/ std::shared_ptr<InstanceImpl> InstanceImpl::MakeAndLoadBundle(
-    std::shared_ptr<Instance> &&instance,
-    std::string &&jsBundleBasePath,
-    std::string &&jsBundleRelativePath,
-    std::vector<
-        std::tuple<std::string, facebook::xplat::module::CxxModule::Provider, std::shared_ptr<MessageQueueThread>>>
-        &&cxxModules,
-    std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
-    std::unique_ptr<InstanceCallback> &&callback,
-    std::shared_ptr<MessageQueueThread> jsQueue,
-    std::shared_ptr<MessageQueueThread> nativeQueue,
-    std::shared_ptr<DevSettings> devSettings,
-    std::shared_ptr<IDevSupportManager> devManager) noexcept {
-  auto inner = std::shared_ptr<InstanceImpl>(new InstanceImpl(
-      std::move(instance),
-      std::move(jsBundleBasePath),
-      std::move(cxxModules),
-      std::move(turboModuleRegistry),
-      nullptr, // longLivedObjectCollection
-      nullptr, // PropertyBag
-      std::move(callback),
-      std::move(jsQueue),
-      std::move(nativeQueue),
-      std::move(devSettings),
-      std::move(devManager)));
-
-  inner->loadBundle(std::move(jsBundleRelativePath));
-  inner->RegisterForReloadIfNecessary();
-
-  return inner;
-}
+  static void fileDataDeleter(void *p) {
+    WerUnregisterMemoryBlock(p);
+    UnmapViewOfFile(p);
+  }
 
-void InstanceImpl::SetInError() noexcept {
-  m_isInError = true;
-}
+  std::unique_ptr<void, decltype(&CloseHandle)> m_fileMapping;
+  std::unique_ptr<void, decltype(&fileDataDeleter)> m_fileData;
+  std::unique_ptr<char, void (*)(void *)> m_data;
+  uint32_t m_fileSize;
+  uint32_t m_size;
+};
 
-InstanceImpl::InstanceImpl(
-    std::shared_ptr<Instance> &&instance,
-    std::string &&jsBundleBasePath,
-    std::vector<
-        std::tuple<std::string, facebook::xplat::module::CxxModule::Provider, std::shared_ptr<MessageQueueThread>>>
-        &&cxxModules,
-    std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
-    std::shared_ptr<facebook::react::LongLivedObjectCollection> longLivedObjectCollection,
-    const winrt::Microsoft::ReactNative::IReactPropertyBag &propertyBag,
-    std::unique_ptr<InstanceCallback> &&callback,
-    std::shared_ptr<MessageQueueThread> jsQueue,
-    std::shared_ptr<MessageQueueThread> nativeQueue,
-    std::shared_ptr<DevSettings> devSettings,
-    std::shared_ptr<IDevSupportManager> devManager)
-    : m_turboModuleRegistry(std::move(turboModuleRegistry)),
-      m_longLivedObjectCollection(std::move(longLivedObjectCollection)),
-      m_jsThread(std::move(jsQueue)),
-      m_nativeQueue(nativeQueue),
-      m_jsBundleBasePath(std::move(jsBundleBasePath)),
-      m_devSettings(std::move(devSettings)),
-      m_devManager(std::move(devManager)),
-      m_innerInstance(std::move(instance)) {
-  // Temp set the logmarker here
-  facebook::react::ReactMarker::logTaggedMarkerImpl = logMarker;
-
-#ifdef ENABLE_ETW_TRACING
-  // TODO :: Find a better place to initialize ETW once per process.
-  facebook::react::tracing::initializeETW();
+FileMappingBigString::FileMappingBigString(const std::wstring &filename, uint32_t offset)
+    : JSBigString{},
+      m_fileMapping{nullptr, &CloseHandle},
+      m_fileData{nullptr, &fileDataDeleter},
+      m_data{nullptr, nullptr},
+      m_size{0},
+      m_fileSize{0} {
+#if (defined(WINRT))
+  std::unique_ptr<void, decltype(&CloseHandle)> fileHandle{
+      CreateFile2(filename.c_str(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr /* pCreateExParams */),
+      &CloseHandle};
+#else
+  std::unique_ptr<void, decltype(&CloseHandle)> fileHandle{
+      CreateFileW(
+          filename.c_str(),
+          GENERIC_READ,
+          FILE_SHARE_READ,
+          nullptr /* lpSecurityAttributes */,
+          OPEN_EXISTING,
+          FILE_ATTRIBUTE_NORMAL,
+          nullptr /* hTemplateFile */),
+      &CloseHandle};
 #endif
 
-  if (m_devSettings->useDirectDebugger) {
-    m_devManager->EnsureInspectorPackagerConnection(
-        m_devSettings->sourceBundleHost, m_devSettings->sourceBundlePort, m_devSettings->bundleAppId);
+  if (fileHandle.get() == INVALID_HANDLE_VALUE) {
+    return;
   }
 
-  std::vector<std::unique_ptr<NativeModule>> modules;
-
-  // Add app provided modules.
-  for (auto &cxxModule : cxxModules) {
-    modules.push_back(std::make_unique<CxxNativeModule>(
-        m_innerInstance, move(std::get<0>(cxxModule)), move(std::get<1>(cxxModule)), move(std::get<2>(cxxModule))));
+  LARGE_INTEGER size;
+  if (!GetFileSizeEx(fileHandle.get(), &size)) {
+    return;
   }
-  m_moduleRegistry = std::make_shared<facebook::react::ModuleRegistry>(std::move(modules));
-
-  // Choose JSExecutor
-  std::shared_ptr<JSExecutorFactory> jsef;
-  if (m_devSettings->useWebDebugger) {
-    try {
-      auto jseFunc = m_devManager->LoadJavaScriptInProxyMode(*m_devSettings, [weakthis = weak_from_this()]() {
-        if (auto strongThis = weakthis.lock()) {
-          strongThis->SetInError();
-        }
-      });
-
-      if ((jseFunc == nullptr) || m_isInError) {
-        m_devSettings->errorCallback("Failed to create JavaScript Executor.");
-        return;
-      }
-
-      jsef = std::make_shared<WebSocketJSExecutorFactory>(std::move(jseFunc));
-    } catch (std::exception &e) {
-      m_devSettings->errorCallback(e.what());
-      return;
-    }
-  } else {
-    if (m_devSettings->useFastRefresh || m_devSettings->liveReloadCallback) {
-      Microsoft::ReactNative::PackagerConnection::CreateOrReusePackagerConnection(*m_devSettings);
-    }
 
-    // If the consumer gives us a JSI runtime, then  use it.
-    if (m_devSettings->jsiRuntimeHolder) {
-      assert(m_devSettings->jsiEngineOverride == JSIEngineOverride::Default);
-      jsef = std::make_shared<OJSIExecutorFactory>(
-          m_devSettings->jsiRuntimeHolder, m_devSettings->loggingCallback, !m_devSettings->useFastRefresh);
-    } else if (m_devSettings->jsExecutorFactoryDelegate != nullptr) {
-      jsef = m_devSettings->jsExecutorFactoryDelegate(m_innerInstance->getJSCallInvoker());
-    } else {
-      assert(m_devSettings->jsiEngineOverride != JSIEngineOverride::Default);
-      switch (m_devSettings->jsiEngineOverride) {
-        case JSIEngineOverride::Hermes: {
-          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
-
-          wchar_t tempPath[MAX_PATH];
-          if (GetTempPathW(MAX_PATH, tempPath)) {
-            preparedScriptStore =
-                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
-          }
-
-          m_devSettings->jsiRuntimeHolder = std::make_shared<Microsoft::ReactNative::HermesRuntimeHolder>(
-              m_devSettings, m_jsThread, std::move(preparedScriptStore));
-          break;
-        }
-        case JSIEngineOverride::V8: {
-#if defined(USE_V8)
-          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
+  if (size.LowPart == 0 || size.HighPart != 0) {
+    return;
+  }
 
-          wchar_t tempPath[MAX_PATH];
-          if (GetTempPathW(MAX_PATH, tempPath)) {
-            preparedScriptStore =
-                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
-          }
+  m_fileSize = size.LowPart;
+  if (offset > m_fileSize) {
+    offset = m_fileSize;
+  }
+  m_size = m_fileSize - offset;
 
-          m_devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
-              m_devSettings, m_jsThread, nullptr, std::move(preparedScriptStore), /*multithreading*/ false);
-          break;
+#if (defined(WINRT))
+  m_fileMapping.reset(CreateFileMappingFromApp(
+      fileHandle.get(), nullptr /* SecurityAttributes */, PAGE_READONLY, m_fileSize, nullptr /* Name */));
 #else
-          assert(false); // V8 is not available in this build, fallthrough
-          [[fallthrough]];
+  m_fileMapping.reset(CreateFileMapping(
+      fileHandle.get(),
+      nullptr /* lpAttributes */,
+      PAGE_READONLY,
+      0 /* dwMaximumSizeHigh */,
+      m_fileSize,
+      nullptr /* lpName */));
 #endif
-        }
-        case JSIEngineOverride::V8NodeApi: {
-#if defined(USE_V8)
-          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
 
-          wchar_t tempPath[MAX_PATH];
-          if (GetTempPathW(MAX_PATH, tempPath)) {
-            preparedScriptStore =
-                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
-          }
-
-          m_devSettings->jsiRuntimeHolder = make_shared<Microsoft::ReactNative::V8RuntimeHolder>(
-              m_devSettings, m_jsThread, std::move(preparedScriptStore), false);
-          break;
-#else
-          if (m_devSettings->errorCallback)
-            m_devSettings->errorCallback("JSI/V8/NAPI engine is not available in this build");
-          assert(false);
-          [[fallthrough]];
-#endif
-        }
-        case JSIEngineOverride::Chakra:
-        default: // TODO: Add other engines once supported
-          m_devSettings->jsiRuntimeHolder =
-              std::make_shared<Microsoft::JSI::ChakraRuntimeHolder>(m_devSettings, m_jsThread, nullptr, nullptr);
-          break;
-      }
-      jsef = std::make_shared<OJSIExecutorFactory>(
-          m_devSettings->jsiRuntimeHolder, m_devSettings->loggingCallback, !m_devSettings->useFastRefresh);
-    }
+  if (!m_fileMapping) {
+    m_size = 0;
+    return;
   }
 
-  m_innerInstance->initializeBridge(
-      std::move(callback), jsef, m_jsThread, m_moduleRegistry, m_devSettings->inspectorHostTarget);
-
-  // For RuntimeScheduler to work properly, we need to install TurboModuleManager with RuntimeSchedulerCallbackInvoker.
-  // To be able to do that, we need to be able to call m_innerInstance->getRuntimeExecutor(), which we can only do after
-  // m_innerInstance->initializeBridge(...) is called.
-  if (!m_devSettings->useWebDebugger) {
-    const auto runtimeExecutor = m_innerInstance->getRuntimeExecutor();
-#ifdef USE_FABRIC
-    Microsoft::ReactNative::SchedulerSettings::SetRuntimeExecutor(
-        winrt::Microsoft::ReactNative::ReactPropertyBag(propertyBag), runtimeExecutor);
+#if (defined(WINRT))
+  m_fileData.reset(
+      MapViewOfFileFromApp(m_fileMapping.get(), FILE_MAP_READ, 0 /* FileOffset */, 0 /* NumberOfBytesToMap */));
+#else
+  m_fileData.reset(MapViewOfFile(
+      m_fileMapping.get(),
+      FILE_MAP_READ,
+      0 /* dwFileOffsetHigh */,
+      0 /* dwFileOffsetLow */,
+      0 /* dwNumberOfBytesToMap */));
 #endif
-    if (m_devSettings->useRuntimeScheduler) {
-      m_runtimeScheduler = std::make_shared<RuntimeScheduler>(runtimeExecutor);
-      Microsoft::ReactNative::SchedulerSettings::SetRuntimeScheduler(
-          winrt::Microsoft::ReactNative::ReactPropertyBag(propertyBag), m_runtimeScheduler);
-    }
 
-    // Using runOnQueueSync because initializeBridge calls createJSExecutor with runOnQueueSync,
-    // so this is an attempt to keep the same semantics for exiting this method with TurboModuleManager
-    // initialized.
-    m_jsThread->runOnQueueSync([propertyBag,
-                                innerInstance = m_innerInstance,
-                                runtimeHolder = m_devSettings->jsiRuntimeHolder,
-                                runtimeScheduler = m_runtimeScheduler,
-                                turboModuleRegistry = m_turboModuleRegistry,
-                                longLivedObjectCollection = m_longLivedObjectCollection]() {
-      if (runtimeScheduler) {
-        RuntimeSchedulerBinding::createAndInstallIfNeeded(*runtimeHolder->getRuntime(), runtimeScheduler);
-      }
-      auto turboModuleManager = std::make_shared<TurboModuleManager>(
-          turboModuleRegistry,
-          runtimeScheduler ? std::make_shared<RuntimeSchedulerCallInvoker>(runtimeScheduler)
-                           : innerInstance->getJSCallInvoker());
-
-      // TODO: The binding here should also add the proxys that convert cxxmodules into turbomodules
-      // [@vmoroz] Note, that we must not use the RN TurboCxxModule.h code because it uses global
-      // LongLivedObjectCollection instance that prevents us from using multiple RN instance in the same process.
-      auto binding = [turboModuleManager](const std::string &name) -> std::shared_ptr<TurboModule> {
-        return turboModuleManager->getModule(name);
-      };
-
-      TurboModuleBinding::install(
-          *runtimeHolder->getRuntime(), std::function(binding), nullptr, longLivedObjectCollection);
-
-      // init TurboModule
-      for (const auto &moduleName : turboModuleManager->getEagerInitModuleNames()) {
-        turboModuleManager->getModule(moduleName);
-      }
-    });
+  if (!m_fileData) {
+    m_size = 0;
+    return;
   }
 
-  // All JSI runtimes do support host objects and hence the native modules
-  // proxy.
-  const bool isNativeModulesProxyAvailable = ((m_devSettings->jsiRuntimeHolder != nullptr) ||
-                                              (m_devSettings->jsiEngineOverride != JSIEngineOverride::Default)) &&
-      !m_devSettings->useWebDebugger;
-  if (!isNativeModulesProxyAvailable) {
-    folly::dynamic configArray = folly::dynamic::array;
-    for (auto const &moduleName : m_moduleRegistry->moduleNames()) {
-      auto moduleConfig = m_moduleRegistry->getConfig(moduleName);
-      configArray.push_back(moduleConfig ? std::move(moduleConfig->config) : nullptr);
-    }
+  WerRegisterMemoryBlock(m_fileData.get(), m_fileSize);
 
-    folly::dynamic configs = folly::dynamic::object("remoteModuleConfig", std::move(configArray));
-    m_innerInstance->setGlobalVariable(
-        "__fbBatchedBridgeConfig", std::make_unique<JSBigStdString>(folly::toJson(configs)));
+  static const uint32_t s_pageSize = getPageSize();
+  if (m_fileSize % s_pageSize != 0) {
+    // Data are owned by m_fileData, deleter is no-op
+    m_data = decltype(m_data){static_cast<char *>(m_fileData.get()) + offset, [](void *) {}};
+  } else {
+    // Ensure m_data is null-terminated
+    m_data = decltype(m_data){
+        new char[m_size + 1],
+        [](void *pv) // Can't just say &operator delete[] because of calling
+                     // convention mismatches
+        { delete[] static_cast<char *>(pv); }};
+    memcpy(m_data.get(), static_cast<char *>(m_fileData.get()) + offset, m_size);
+    m_data.get()[m_size] = '\0';
   }
 }
 
-void InstanceImpl::loadBundle(std::string &&jsBundleRelativePath) {
-  loadBundleInternal(std::move(jsBundleRelativePath), /*synchronously:*/ false);
-}
-
-void InstanceImpl::loadBundleSync(std::string &&jsBundleRelativePath) {
-  loadBundleInternal(std::move(jsBundleRelativePath), /*synchronously:*/ true);
-}
-
-void InstanceImpl::loadBundleInternal(std::string &&jsBundleRelativePath, bool synchronously) {
-  try {
-    if (m_devSettings->useWebDebugger || m_devSettings->liveReloadCallback != nullptr ||
-        m_devSettings->useFastRefresh) {
-      Microsoft::ReactNative::LoadRemoteUrlScript(
-          m_devSettings,
-          m_devManager,
-          std::move(jsBundleRelativePath),
-          [=](std::unique_ptr<const JSBigStdString> script, const std::string &sourceURL) {
-            m_innerInstance->loadScriptFromString(std::move(script), sourceURL, false);
-          });
-
-    } else {
-      auto bundleString = Microsoft::ReactNative::JsBigStringFromPath(m_devSettings, jsBundleRelativePath);
-      m_innerInstance->loadScriptFromString(std::move(bundleString), std::move(jsBundleRelativePath), synchronously);
-    }
-  } catch (const std::exception &e) {
-    m_devSettings->errorCallback(e.what());
-  } catch (const winrt::hresult_error &hrerr) {
-    auto error = fmt::format("[0x{:0>8x}] {}", static_cast<uint32_t>(hrerr.code()), winrt::to_string(hrerr.message()));
-
-    m_devSettings->errorCallback(std::move(error));
-  }
+std::unique_ptr<const FileMappingBigString> FileMappingBigString::fromPath(const std::wstring &filename) {
+  return std::make_unique<FileMappingBigString>(filename);
 }
 
-InstanceImpl::~InstanceImpl() {
-  if (m_devSettings->inspectorHostTarget) {
-    Mso::React::MessageDispatchQueue messageDispatchQueue{
-        ::Microsoft::ReactNative::ReactInspectorThread::Instance(), nullptr};
-    messageDispatchQueue.runOnQueueSync([weakInnerInstance = std::weak_ptr(m_innerInstance)]() {
-      if (std::shared_ptr<facebook::react::Instance> innerInstance = weakInnerInstance.lock()) {
-        innerInstance->unregisterFromInspector();
-      }
-    });
+std::unique_ptr<const facebook::react::JSBigString> JsBigStringFromPath(
+    std::shared_ptr<facebook::react::DevSettings> devSettings,
+    const std::string &jsBundleRelativePath) noexcept {
+#if (defined(_MSC_VER) && !defined(WINRT))
+  std::wstring bundlePath = (fs::u8path(devSettings->bundleRootPath) / jsBundleRelativePath).wstring();
+  return FileMappingBigString::fromPath(bundlePath);
+#else
+  std::wstring bundlePath;
+  if (devSettings->bundleRootPath.starts_with("resource://")) {
+    auto uri = winrt::Windows::Foundation::Uri(
+        winrt::to_hstring(devSettings->bundleRootPath), winrt::to_hstring(jsBundleRelativePath));
+    bundlePath = uri.ToString();
+  } else {
+    bundlePath = (fs::u8path(devSettings->bundleRootPath) / (jsBundleRelativePath + ".bundle")).wstring();
   }
 
-  m_nativeQueue->quitSynchronous();
-}
-
-void InstanceImpl::RegisterForReloadIfNecessary() noexcept {
-  // setup polling for live reload
-  if (!m_isInError && !m_devSettings->useFastRefresh && m_devSettings->liveReloadCallback != nullptr) {
-    m_devManager->StartPollingLiveReload(
-        m_devSettings->sourceBundleHost, m_devSettings->sourceBundlePort, m_devSettings->liveReloadCallback);
-  }
+  return std::make_unique<::Microsoft::ReactNative::StorageFileBigString>(bundlePath);
+#endif
 }
 
-void InstanceImpl::DispatchEvent(int64_t viewTag, std::string eventName, folly::dynamic &&eventData) {
-  if (m_isInError) {
-    return;
-  }
-
-  folly::dynamic params = folly::dynamic::array(viewTag, eventName, std::move(eventData));
-  m_innerInstance->callJSFunction("RCTEventEmitter", "receiveEvent", std::move(params));
-}
+} // namespace Microsoft::ReactNative
 
-void InstanceImpl::invokeCallback(const int64_t callbackId, folly::dynamic &&params) {
-  if (m_isInError) {
-    return;
-  }
+namespace facebook::react {
 
-  m_innerInstance->callJSCallback(callbackId, std::move(params));
-}
+void logMarker(int /*id*/, const char * /*tag*/) {}
 
 } // namespace facebook::react