one 2.10.0 → 2.11.1

package/native-core/host/OneHostModules.cpp

@@ -0,0 +1,355 @@
+#include "OneHostModules.h"
+
+#include <chrono>
+
+#include <folly/json.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/nativemodule/dom/NativeDOM.h>
+#include <react/nativemodule/idlecallbacks/NativeIdleCallbacks.h>
+
+namespace facebook::react {
+
+namespace {
+
+// React Native version the host links; reported through PlatformConstants
+constexpr int kReactNativeMajor = 0;
+constexpr int kReactNativeMinor = 88;
+constexpr int kReactNativePatch = 0;
+
+folly::dynamic dimensions(const OneHostWindowMetrics &metrics)
+{
+  folly::dynamic size = folly::dynamic::object("width", metrics.width)("height", metrics.height)(
+      "scale", metrics.scale)("fontScale", 1);
+  return folly::dynamic::object("window", size)("screen", size);
+}
+
+std::shared_ptr<OneHostModule> platformConstants(
+    std::shared_ptr<CallInvoker> invoker,
+    const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("PlatformConstants", std::move(invoker));
+  module->constants(folly::dynamic::object("isTesting", false)(
+      "reactNativeVersion",
+      folly::dynamic::object("major", kReactNativeMajor)("minor", kReactNativeMinor)("patch", kReactNativePatch))(
+      "osVersion", context.osVersion)("interfaceIdiom", context.interfaceIdiom)("forceTouchAvailable", false)(
+      "isDisableAnimations", false));
+  return module;
+}
+
+std::shared_ptr<OneHostModule> deviceInfo(
+    std::shared_ptr<CallInvoker> invoker,
+    const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("DeviceInfo", std::move(invoker));
+  module->method("getConstants", 0, [context](jsi::Runtime &rt, const jsi::Value *, size_t) {
+    return jsi::valueFromDynamic(rt, folly::dynamic::object("Dimensions", dimensions(context.windowMetrics())));
+  });
+  return module;
+}
+
+// the window's content view is not covered by the title bar, so insets are zero
+std::shared_ptr<OneHostModule> safeAreaContext(
+    std::shared_ptr<CallInvoker> invoker,
+    const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("OneNativeSafeAreaContext", std::move(invoker));
+  module->method("getConstants", 0, [context](jsi::Runtime &rt, const jsi::Value *, size_t) {
+    auto metrics = context.windowMetrics();
+    return jsi::valueFromDynamic(
+        rt,
+        folly::dynamic::object(
+            "initialWindowMetrics",
+            folly::dynamic::object(
+                "insets", folly::dynamic::object("top", 0)("right", 0)("bottom", 0)("left", 0))(
+                "frame",
+                folly::dynamic::object("x", 0)("y", 0)("width", metrics.width)("height", metrics.height))));
+  });
+  return module;
+}
+
+std::shared_ptr<OneHostModule> soundManager(std::shared_ptr<CallInvoker> invoker)
+{
+  auto module = std::make_shared<OneHostModule>("SoundManager", std::move(invoker));
+  module->noop("playTouchSound");
+  return module;
+}
+
+std::shared_ptr<OneHostModule> frameRateLogger(std::shared_ptr<CallInvoker> invoker)
+{
+  auto module = std::make_shared<OneHostModule>("FrameRateLogger", std::move(invoker));
+  module->noop("setGlobalOptions");
+  module->noop("setContext");
+  module->noop("beginScroll");
+  module->noop("endScroll");
+  return module;
+}
+
+// no software keyboard on a desktop, so nothing is ever emitted
+std::shared_ptr<OneHostModule> keyboardObserver(std::shared_ptr<CallInvoker> invoker)
+{
+  auto module = std::make_shared<OneHostModule>("KeyboardObserver", std::move(invoker));
+  module->noop("addListener");
+  module->noop("removeListeners");
+  return module;
+}
+
+std::shared_ptr<OneHostModule> sourceCode(std::shared_ptr<CallInvoker> invoker, const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("SourceCode", std::move(invoker));
+  module->constants(folly::dynamic::object("scriptURL", context.scriptURL));
+  return module;
+}
+
+std::shared_ptr<OneHostModule> appearance(std::shared_ptr<CallInvoker> invoker, const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("Appearance", std::move(invoker));
+  module->method("getColorScheme", 0, [context](jsi::Runtime &rt, const jsi::Value *, size_t) {
+    return jsi::String::createFromUtf8(rt, context.colorScheme());
+  });
+  module->method("setColorScheme", 1, [](jsi::Runtime &, const jsi::Value *, size_t) {
+    return jsi::Value::undefined();
+  });
+  addEventEmitterStubs(*module);
+  return module;
+}
+
+std::shared_ptr<OneHostModule> appState(std::shared_ptr<CallInvoker> invoker)
+{
+  auto module = std::make_shared<OneHostModule>("AppState", std::move(invoker));
+  module->constants(folly::dynamic::object("initialAppState", "active"));
+  module->method("getCurrentAppState", 2, [](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    if (count > 0 && args[0].isObject()) {
+      auto state = jsi::Object(rt);
+      state.setProperty(rt, "app_state", jsi::String::createFromUtf8(rt, "active"));
+      args[0].getObject(rt).asFunction(rt).call(rt, state);
+    }
+    return jsi::Value::undefined();
+  });
+  addEventEmitterStubs(*module);
+  return module;
+}
+
+std::shared_ptr<OneHostModule> i18nManager(std::shared_ptr<CallInvoker> invoker, const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("I18nManager", std::move(invoker));
+  module->constants(folly::dynamic::object("isRTL", false)("doLeftAndRightSwapInRTL", true)(
+      "localeIdentifier", context.localeIdentifier));
+  module->noop("allowRTL");
+  module->noop("forceRTL");
+  module->noop("swapLeftAndRightInRTL");
+  return module;
+}
+
+std::shared_ptr<OneHostModule> exceptionsManager(std::shared_ptr<CallInvoker> invoker, const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("ExceptionsManager", std::move(invoker));
+  module->method("reportException", 1, [context](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    if (count > 0 && args[0].isObject()) {
+      folly::dynamic error = jsi::dynamicFromValue(rt, args[0]);
+      context.log("js exception: " + folly::toJson(error));
+    }
+    return jsi::Value::undefined();
+  });
+  module->method("reportFatalException", 3, [context](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    context.log("js fatal: " + stringArg(rt, args, count, 0));
+    return jsi::Value::undefined();
+  });
+  module->noop("dismissRedbox");
+  module->noop("updateExceptionMessage");
+  return module;
+}
+
+std::shared_ptr<OneHostModule> logBox(std::shared_ptr<CallInvoker> invoker)
+{
+  auto module = std::make_shared<OneHostModule>("LogBox", std::move(invoker));
+  module->noop("show");
+  module->noop("hide");
+  return module;
+}
+
+std::shared_ptr<OneHostModule> devSettings(std::shared_ptr<CallInvoker> invoker, const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("DevSettings", std::move(invoker));
+  module->method("reload", 0, [context](jsi::Runtime &, const jsi::Value *, size_t) {
+    context.reload();
+    return jsi::Value::undefined();
+  });
+  module->method("reloadWithReason", 1, [context](jsi::Runtime &, const jsi::Value *, size_t) {
+    context.reload();
+    return jsi::Value::undefined();
+  });
+  module->noop("onFastRefresh");
+  module->noop("setHotLoadingEnabled");
+  module->noop("setIsDebuggingRemotely");
+  module->noop("setProfilingEnabled");
+  module->noop("toggleElementInspector");
+  module->noop("addMenuItem");
+  module->noop("openDebugger");
+  addEventEmitterStubs(*module);
+  return module;
+}
+
+std::shared_ptr<TurboModule> performance(std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto module = std::make_shared<OneHostModule>("NativePerformanceCxx", std::move(jsInvoker));
+  module->method("now", 0, [](jsi::Runtime &, const jsi::Value *, size_t) {
+    auto elapsed = std::chrono::steady_clock::now().time_since_epoch();
+    return jsi::Value(std::chrono::duration<double, std::milli>(elapsed).count());
+  });
+  module->noop("reportMark");
+  module->noop("reportMeasure");
+  module->noop("clearMarks");
+  module->noop("clearMeasures");
+  return module;
+}
+
+std::shared_ptr<TurboModule> microtasks(std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto module = std::make_shared<OneHostModule>("NativeMicrotasksCxx", std::move(jsInvoker));
+  module->method("queueMicrotask", 1, [](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    if (count > 0 && args[0].isObject() && args[0].getObject(rt).isFunction(rt)) {
+      rt.queueMicrotask(args[0].getObject(rt).getFunction(rt));
+    }
+    return jsi::Value::undefined();
+  });
+  return module;
+}
+
+std::shared_ptr<TurboModule> settingsManager(std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto module = std::make_shared<OneHostModule>("SettingsManager", std::move(jsInvoker));
+  module->constants(folly::dynamic::object("settings", folly::dynamic::object()));
+  module->noop("setValues");
+  module->noop("deleteValues");
+  return module;
+}
+
+std::shared_ptr<TurboModule> devLoadingView(std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto module = std::make_shared<OneHostModule>("DevLoadingView", std::move(jsInvoker));
+  module->noop("showMessage");
+  module->noop("hide");
+  return module;
+}
+
+std::shared_ptr<TurboModule> devToolsRuntimeSettings(std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto module = std::make_shared<OneHostModule>("ReactDevToolsRuntimeSettingsModule", std::move(jsInvoker));
+  module->method("getReloadAndProfileConfig", 0, [](jsi::Runtime &rt, const jsi::Value *, size_t) {
+    return jsi::valueFromDynamic(
+        rt, folly::dynamic::object("shouldReloadAndProfile", false)("recordChangeDescriptions", false));
+  });
+  module->noop("setReloadAndProfileConfig");
+  return module;
+}
+
+// accessors answer undefined, so the JS flag getters keep their defaults,
+// except the flags below: a mouse hovers through W3C pointer events here, since
+// Pressability only wires onMouseEnter for web, and Animated runs on the C++
+// animated renderer when the host registers a NativeAnimatedModule
+std::shared_ptr<TurboModule> featureFlags(std::shared_ptr<CallInvoker> jsInvoker, const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("NativeReactNativeFeatureFlagsCxx", std::move(jsInvoker));
+  module->wildcard = true;
+  module->method("shouldPressibilityUseW3CPointerEventsForHover", 0, [](jsi::Runtime &, const jsi::Value *, size_t) {
+    return jsi::Value(true);
+  });
+  bool cxxNativeAnimated = context.cxxNativeAnimated;
+  module->method("cxxNativeAnimatedEnabled", 0, [cxxNativeAnimated](jsi::Runtime &, const jsi::Value *, size_t) {
+    return jsi::Value(cxxNativeAnimated);
+  });
+  return module;
+}
+
+} // namespace
+
+// menu validation and listener state are shared by desktop command modules.
+std::shared_ptr<TurboModule> OneHostCreateAppCommandsModule(const std::string &name, std::shared_ptr<CallInvoker> jsInvoker, const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>(name, std::move(jsInvoker));
+  module->method("configure", 1, [context](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    auto error = context.configureAppCommands(count > 0 ? jsi::dynamicFromValue(rt, args[0]) : folly::dynamic());
+    if (!error.empty()) {
+      throw jsi::JSError(rt, "AppCommands.configure: " + error);
+    }
+    return jsi::Value::undefined();
+  });
+  module->method("setListening", 1, [context](jsi::Runtime &, const jsi::Value *args, size_t count) {
+    context.setAppCommandsListening(count > 0 && args[0].isBool() && args[0].getBool());
+    return jsi::Value::undefined();
+  });
+  return module;
+}
+
+std::shared_ptr<TurboModule> OneHostCreateTurboModule(
+    const std::string &name,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    const OneHostModuleContext &context)
+{
+  if (name == "NativePerformanceCxx") {
+    return performance(std::move(jsInvoker));
+  }
+  if (name == "NativeMicrotasksCxx") {
+    return microtasks(std::move(jsInvoker));
+  }
+  if (name == "SettingsManager") {
+    return settingsManager(std::move(jsInvoker));
+  }
+  if (name == "DevLoadingView") {
+    return devLoadingView(std::move(jsInvoker));
+  }
+  if (name == "ReactDevToolsRuntimeSettingsModule") {
+    return devToolsRuntimeSettings(std::move(jsInvoker));
+  }
+  if (name == "NativeReactNativeFeatureFlagsCxx") {
+    return featureFlags(std::move(jsInvoker), context);
+  }
+  if (name == "NativeDOMCxx") {
+    return std::make_shared<NativeDOM>(std::move(jsInvoker));
+  }
+  if (name == "NativeIdleCallbacksCxx") {
+    return std::make_shared<NativeIdleCallbacks>(std::move(jsInvoker));
+  }
+  if (name == "PlatformConstants") {
+    return platformConstants(std::move(jsInvoker), context);
+  }
+  if (name == "DeviceInfo") {
+    return deviceInfo(std::move(jsInvoker), context);
+  }
+  if (name == "SourceCode") {
+    return sourceCode(std::move(jsInvoker), context);
+  }
+  if (name == "Appearance") {
+    return appearance(std::move(jsInvoker), context);
+  }
+  if (name == "AppState") {
+    return appState(std::move(jsInvoker));
+  }
+  if (name == "I18nManager") {
+    return i18nManager(std::move(jsInvoker), context);
+  }
+  if (name == "ExceptionsManager") {
+    return exceptionsManager(std::move(jsInvoker), context);
+  }
+  if (name == "LogBox") {
+    return logBox(std::move(jsInvoker));
+  }
+  if (name == "DevSettings") {
+    return devSettings(std::move(jsInvoker), context);
+  }
+  if (name == "SoundManager") {
+    return soundManager(std::move(jsInvoker));
+  }
+  if (name == "FrameRateLogger") {
+    return frameRateLogger(std::move(jsInvoker));
+  }
+  if (name == "KeyboardObserver") {
+    return keyboardObserver(std::move(jsInvoker));
+  }
+  if (name == "OneNativeSafeAreaContext") {
+    return safeAreaContext(std::move(jsInvoker), context);
+  }
+  return nullptr;
+}
+
+} // namespace facebook::react

package/native-core/host/OneHostModules.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "OneHostModule.h"
+
+namespace facebook::react {
+
+std::shared_ptr<TurboModule> OneHostCreateAppCommandsModule(
+    const std::string &name, std::shared_ptr<CallInvoker> jsInvoker, const OneHostModuleContext &context);
+
+// The TurboModules both hosts provide the same way: platform constants, device
+// info, appearance, app state, exception reporting, dev settings, the C++
+// performance, microtask, DOM and idle callback modules, and the inert
+// stand-ins for modules with nothing to do on a desktop. Returns nullptr for
+// any other name.
+std::shared_ptr<TurboModule> OneHostCreateTurboModule(
+    const std::string &name,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    const OneHostModuleContext &context);
+
+} // namespace facebook::react

package/native-core/host/OneHostRuntime.cpp

@@ -0,0 +1,314 @@
+#include "OneHostRuntime.h"
+
+#include <ReactCommon/TurboModuleBinding.h>
+#include <jsi/jsi.h>
+#include <react/renderer/componentregistry/native/NativeComponentRegistryBinding.h>
+#include <react/renderer/core/ReactRootViewTagGenerator.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+#include <react/renderer/scheduler/SchedulerToolbox.h>
+#include <react/runtime/JSRuntimeBindings.h>
+#include <react/runtime/TimerManager.h>
+#include <react/runtime/hermes/HermesInstance.h>
+
+#include <future>
+
+#include "OneHostModules.h"
+
+namespace facebook::react {
+
+void OneMessageQueueThread::runOnQueueSync(std::function<void()> &&work)
+{
+  if (isOnThread()) {
+    work();
+    return;
+  }
+  std::promise<void> done;
+  auto finished = done.get_future();
+  runOnQueue([work = std::move(work), &done]() {
+    work();
+    done.set_value();
+  });
+  finished.wait();
+}
+
+void OneTimerRegistry::setTimerManager(std::weak_ptr<TimerManager> timerManager)
+{
+  std::lock_guard<std::mutex> lock(mutex_);
+  timerManager_ = timerManager;
+}
+
+void OneTimerRegistry::createTimer(uint32_t timerID, double delayMS)
+{
+  arm(timerID, delayMS, false);
+}
+
+void OneTimerRegistry::createRecurringTimer(uint32_t timerID, double delayMS)
+{
+  arm(timerID, delayMS, true);
+}
+
+void OneTimerRegistry::deleteTimer(uint32_t timerID)
+{
+  disarm(timerID);
+}
+
+void OneTimerRegistry::quit()
+{
+  disarmAll();
+}
+
+void OneTimerRegistry::fire(uint32_t timerID, bool repeats)
+{
+  std::shared_ptr<TimerManager> manager;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    manager = timerManager_.lock();
+  }
+  if (!repeats) {
+    disarm(timerID);
+  }
+  if (manager) {
+    manager->callTimer(timerID);
+  }
+}
+
+OneHostRuntime::OneHostRuntime(OneHostRuntimeOptions options) : jsThread_(std::move(options.jsThread))
+{
+  auto timerRegistry = std::move(options.timerRegistry);
+  auto *timerRegistryPtr = timerRegistry.get();
+  auto timerManager = std::make_shared<TimerManager>(std::move(timerRegistry));
+  timerRegistryPtr->setTimerManager(timerManager);
+
+  auto logJsError = options.logJsError;
+  auto onJsError = [logJsError](jsi::Runtime &, const JsErrorHandler::ProcessedError &error) {
+    logJsError(error.message);
+  };
+
+  instance_ = std::make_shared<ReactInstance>(
+      HermesInstance::createJSRuntime(nullptr, jsThread_, false), jsThread_, timerManager, onJsError);
+  timerManager->setRuntimeExecutor(instance_->getBufferedRuntimeExecutor());
+
+  std::weak_ptr<ReactInstance> weakInstance = instance_;
+  std::weak_ptr<OneMessageQueueThread> weakJsThread = jsThread_;
+
+  moduleContext_ = std::move(options.moduleContext);
+  createTurboModule_ = std::move(options.createTurboModule);
+  hasComponentProvider_ = std::move(options.hasComponentProvider);
+  logJsMessage_ = std::move(options.logJsMessage);
+  auto &moduleContext = moduleContext_;
+  moduleContext.emitDeviceEvent = [weakInstance](const std::string &name, folly::dynamic payload) {
+    if (auto instance = weakInstance.lock()) {
+      instance->callFunctionOnModule("RCTDeviceEventEmitter", "emit", folly::dynamic::array(name, std::move(payload)));
+    }
+  };
+  moduleContext.isJavaScriptQueue = [weakJsThread]() {
+    auto jsThread = weakJsThread.lock();
+    return jsThread && jsThread->isOnThread();
+  };
+
+  contextContainer_ = std::make_shared<ContextContainer>();
+  contextContainer_->insert(RuntimeSchedulerKey, std::weak_ptr<RuntimeScheduler>(instance_->getRuntimeScheduler()));
+  turboModules_ = std::make_shared<std::unordered_map<std::string, std::shared_ptr<TurboModule>>>();
+}
+
+void OneHostRuntime::initializeRuntime()
+{
+  auto jsCallInvoker = instance_->createJSCallInvoker();
+  auto turboModules = turboModules_;
+  auto moduleContext = moduleContext_;
+  auto createTurboModule = createTurboModule_;
+  auto hasComponentProvider = hasComponentProvider_;
+  auto logJsMessage = logJsMessage_;
+  instance_->initializeRuntime(
+      {}, [turboModules, jsCallInvoker, moduleContext, createTurboModule, hasComponentProvider, logJsMessage](jsi::Runtime &runtime) {
+        TurboModuleBinding::install(
+            runtime,
+            [turboModules, jsCallInvoker, moduleContext, createTurboModule](
+                jsi::Runtime &moduleRuntime, const std::string &name) -> std::shared_ptr<TurboModule> {
+              auto found = turboModules->find(name);
+              if (found != turboModules->end()) {
+                return found->second;
+              }
+              auto module = createTurboModule ? createTurboModule(moduleRuntime, name, jsCallInvoker, moduleContext)
+                                              : OneHostCreateTurboModule(name, jsCallInvoker, moduleContext);
+              (*turboModules)[name] = module;
+              return module;
+            });
+        bindNativeLogger(runtime, logJsMessage);
+        // hermes has no console of its own, so route it through the native logger
+        // before the bundle's own empty console stubs can claim the names
+        runtime.evaluateJavaScript(
+            std::make_shared<jsi::StringBuffer>(
+                "globalThis.console = {};"
+                "['log', 'info', 'warn', 'error', 'debug', 'trace'].forEach(function (name, level) {"
+                "  console[name] = function () {"
+                "    nativeLoggingHook(Array.prototype.map.call(arguments, function (value) {"
+                "      return typeof value === 'string' ? value : (value && value.stack) || String(value);"
+                "    }).join(' '), level);"
+                "  };"
+                "});"),
+            "one-host-console");
+        auto provider = hasComponentProvider;
+        bindHasComponentProvider(runtime, std::move(provider));
+      });
+}
+
+OneHostRuntime::~OneHostRuntime()
+{
+  scheduler_.reset();
+
+  auto instance = std::move(instance_);
+  auto modules = std::move(turboModules_);
+  // the instance and its modules must die on the js thread
+  jsThread_->runOnQueueSync([&] {
+    modules->clear();
+    instance.reset();
+  });
+  jsThread_->quitSynchronous();
+}
+
+void OneHostRuntime::createScheduler(
+    std::shared_ptr<ComponentDescriptorProviderRegistry> providers,
+    std::function<void(SharedComponentDescriptorRegistry)> registryCreated,
+    EventBeatFactory eventBeatFactory,
+    SchedulerDelegate *delegate)
+{
+  auto runtimeScheduler = instance_->getRuntimeScheduler();
+
+  SchedulerToolbox toolbox;
+  toolbox.contextContainer = contextContainer_;
+  toolbox.componentRegistryFactory = [providers, registryCreated = std::move(registryCreated)](
+                                         const EventDispatcher::Weak &eventDispatcher,
+                                         const std::shared_ptr<const ContextContainer> &container) {
+    auto descriptors = providers->createComponentDescriptorRegistry({.eventDispatcher = eventDispatcher, .contextContainer = container});
+    registryCreated(descriptors);
+    return descriptors;
+  };
+  // buffered so surface start waits for the bundle that installs RN$AppRegistry
+  toolbox.runtimeExecutor = instance_->getBufferedRuntimeExecutor();
+  toolbox.bridgelessBindingsExecutor = instance_->getUnbufferedRuntimeExecutor();
+  toolbox.eventBeatFactory = [runtimeScheduler, eventBeatFactory = std::move(eventBeatFactory)](
+                                 std::shared_ptr<EventBeat::OwnerBox> ownerBox) -> std::unique_ptr<EventBeat> {
+    return eventBeatFactory(std::move(ownerBox), *runtimeScheduler);
+  };
+
+  scheduler_ = std::make_unique<Scheduler>(toolbox, nullptr, delegate);
+}
+
+void OneHostRuntime::startSurface(const std::string &moduleName, const std::function<void(SurfaceId)> &attach)
+{
+  surface_.emplace(moduleName, getNextRootViewTag());
+  surface_->setProps(folly::dynamic::object());
+  scheduler_->registerSurface(*surface_);
+  attach(surface_->getSurfaceId());
+  applyLayout();
+  surface_->start();
+}
+
+void OneHostRuntime::stopSurface(const std::function<void(SurfaceId)> &detach)
+{
+  if (surface_) {
+    surface_->stop();
+    scheduler_->unregisterSurface(*surface_);
+    detach(surface_->getSurfaceId());
+    surface_.reset();
+  }
+}
+
+bool OneHostRuntime::updateLayout(double width, double height, double scale)
+{
+  bool changed = width_ != width || height_ != height || scale_ != scale;
+  width_ = width;
+  height_ = height;
+  scale_ = scale;
+  if (changed) {
+    applyLayout();
+  }
+  return changed;
+}
+
+void OneHostRuntime::applyLayout()
+{
+  if (!surface_) {
+    return;
+  }
+  LayoutConstraints constraints = surface_->getLayoutConstraints();
+  LayoutContext context = surface_->getLayoutContext();
+  facebook::react::Size size{static_cast<Float>(width_), static_cast<Float>(height_)};
+  constraints.minimumSize = size;
+  constraints.maximumSize = size;
+  constraints.layoutDirection = LayoutDirection::LeftToRight;
+  context.pointScaleFactor = static_cast<Float>(scale_);
+  context.fontSizeMultiplier = 1;
+  context.viewportSize = size;
+  surface_->constraintLayout(constraints, context);
+}
+
+void OneHostRuntime::emitDeviceEvent(const std::string &name, folly::dynamic payload)
+{
+  instance_->callFunctionOnModule("RCTDeviceEventEmitter", "emit", folly::dynamic::array(name, std::move(payload)));
+}
+
+void OneHostRuntime::emitDimensions()
+{
+  folly::dynamic dims = folly::dynamic::object("width", width_)("height", height_)("scale", scale_)("fontScale", 1);
+  emitDeviceEvent("didUpdateDimensions", folly::dynamic::object("window", dims)("screen", dims));
+}
+
+void OneHostRuntime::updateStateData(SurfaceId surfaceId, const std::unordered_map<Tag, StateDataUpdate> &updates)
+{
+  if (!scheduler_ || updates.empty()) return;
+  scheduler_->getUIManager()->getShadowTreeRegistry().visit(surfaceId, [&](const ShadowTree &tree) {
+    tree.commit([&](const RootShadowNode &root) -> RootShadowNode::Unshared {
+      std::unordered_set<std::shared_ptr<const ShadowNodeFamily>> families;
+      std::function<void(const ShadowNode &)> collect = [&](const ShadowNode &node) {
+        auto found = updates.find(node.getTag());
+        // a newer react commit may have changed the measured props already.
+        if (found != updates.end() && found->second.props == node.getProps()) families.insert(node.getFamilyShared());
+        for (const auto &child : node.getChildren()) collect(*child);
+      };
+      collect(root);
+      if (families.empty()) return nullptr;
+      return std::static_pointer_cast<RootShadowNode>(root.cloneMultiple(families, [&](const ShadowNode &node, const ShadowNodeFragment &fragment) {
+        auto found = updates.find(node.getTag());
+        if (found == updates.end() || found->second.props != node.getProps()) return node.clone(fragment);
+        auto state = node.getFamily().getComponentDescriptor().createState(node.getFamily(), found->second.data);
+        return node.clone({.props = fragment.props, .children = fragment.children, .state = state});
+      }));
+    }, {});
+  });
+}
+
+void OneHostRuntime::mergeReactRevision(SurfaceId surfaceId, const DispatchMain &dispatchMain)
+{
+  bool needsDispatch = false;
+  {
+    std::lock_guard<std::mutex> lock(mergeMutex_);
+    needsDispatch = pendingMerges_.empty();
+    pendingMerges_.insert(surfaceId);
+  }
+  if (!needsDispatch) {
+    return;
+  }
+  std::weak_ptr<OneHostRuntime> weakSelf = weak_from_this();
+  dispatchMain([weakSelf]() {
+    auto self = weakSelf.lock();
+    if (!self) {
+      return;
+    }
+    std::unordered_set<SurfaceId> pending;
+    {
+      std::lock_guard<std::mutex> lock(self->mergeMutex_);
+      pending.swap(self->pendingMerges_);
+    }
+    if (!self->scheduler_) {
+      return;
+    }
+    auto uiManager = self->scheduler_->getUIManager();
+    for (auto id : pending) {
+      uiManager->getShadowTreeRegistry().visit(id, [](const ShadowTree &tree) { tree.mergeReactRevision(); });
+    }
+  });
+}
+
+} // namespace facebook::react