one 2.10.0 → 2.11.1

package/linux/scripts/package-core.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# Builds the packaged core from source and tars it as the prebuilt a release
+# attaches: one-linux-core-<one>-rn<react-native>-<config>-<arch>.tar.gz in $2.
+# CI runs this once per architecture; prepare-core.sh downloads the result.
+#   RN_ROOT  node_modules/react-native
+#   $1       release (default) or debug
+#   $2       output directory (default: the current directory)
+set -euo pipefail
+
+here="$(cd "$(dirname "$0")" && pwd)"
+source "$here/cache.sh"
+
+config="${1:-release}"
+dest="$(mkdir -p "${2:-.}" && cd "${2:-.}" && pwd)"
+name="one-linux-core-$(core_key "$config").tar.gz"
+work="$cache/package-core-$config"
+
+ONE_LINUX_CORE_FROM_SOURCE=1 "$here/prepare-core.sh" "$work" "$config"
+tar -czf "$dest/$name" -C "$work" one-linux libhermesvm.so hermesc
+echo "$dest/$name"

package/linux/scripts/prepare-core.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# Installs the packaged core into $1: one-linux, libhermesvm.so and hermesc side
+# by side, which is everything an app package needs besides the app's bundle.
+# It follows the macOS prepare-deps.sh and prepare-hermes.sh convention: a
+# tarball per version in the user cache, a stamp file in the output and an early
+# exit while the stamp matches. A tarball that cannot be downloaded means the
+# core is built from source with build-core.sh and installed from there.
+#   RN_ROOT                       node_modules/react-native
+#   $2                            release (default) or debug
+#   ONE_LINUX_CORE_URL            full url of the tarball (default: the GitHub
+#                                 release asset of this One version)
+#   ONE_LINUX_CORE_FROM_SOURCE=1  skip the download
+set -euo pipefail
+
+here="$(cd "$(dirname "$0")" && pwd)"
+source "$here/cache.sh"
+
+out="$1"
+config="${2:-release}"
+key="$(core_key "$config")"
+name="one-linux-core-$key.tar.gz"
+stamp="$out/.one-linux-core-version"
+
+if [ -x "$out/one-linux" ] && [ "$(cat "$stamp" 2>/dev/null)" = "$key" ]; then
+  exit 0
+fi
+
+version="$(one_version)"
+# canary versions end in a timestamp and are tagged canary<version>
+if [[ "$version" =~ -[0-9]{10,}$ ]]; then tag="canary$version"; else tag="v$version"; fi
+url="${ONE_LINUX_CORE_URL:-https://github.com/onejs/one/releases/download/$tag/$name}"
+tarball="$cache/downloads/$name"
+
+if [ "${ONE_LINUX_CORE_FROM_SOURCE:-}" != 1 ] && [ ! -f "$tarball" ]; then
+  mkdir -p "$cache/downloads"
+  echo "downloading $url" >&2
+  if curl -fsSL "$url" -o "$tarball.part"; then
+    mv "$tarball.part" "$tarball"
+  else
+    rm -f "$tarball.part"
+    echo "no prebuilt core for $key, building from source" >&2
+  fi
+fi
+
+rm -rf "$out"
+mkdir -p "$out"
+if [ "${ONE_LINUX_CORE_FROM_SOURCE:-}" != 1 ] && [ -f "$tarball" ]; then
+  tar -xzf "$tarball" -C "$out"
+else
+  core="$("$here/build-core.sh" "$config" | tee /dev/stderr | tail -n 1)"
+  cmake --install "$core" --prefix "$out" >/dev/null
+  strip --strip-unneeded "$out/one-linux" "$out/libhermesvm.so" "$out/hermesc"
+fi
+echo "$key" > "$stamp"

package/linux/scripts/prepare-deps.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+# Downloads and lays out the third party sources react-native's Android build
+# compiles (folly, glog, fmt, double-conversion, fast_float and the boost
+# headers) into $1, at the versions pinned in react-native's
+# gradle/libs.versions.toml. The layout is the one ReactAndroid's
+# third-party-ndk directory has, so react-native's own CMake files build it.
+# Tarballs are cached next to the output and reused per react-native version.
+#   RN_ROOT  node_modules/react-native
+set -euo pipefail
+
+here="$(cd "$(dirname "$0")" && pwd)"
+source "$here/cache.sh"
+
+out="$1"
+rn_version="$(rn_version)"
+toml="$RN_ROOT/gradle/libs.versions.toml"
+jni="$RN_ROOT/ReactAndroid/src/main/jni/third-party"
+
+pinned() { sed -n "s/^$1 *= *\"\(.*\)\"/\1/p" "$toml"; }
+boost="$(pinned boost)"
+double_conversion="$(pinned doubleconversion)"
+fast_float="$(pinned fastFloat)"
+fmt="$(pinned fmt)"
+folly="$(pinned folly)"
+glog="$(pinned glog)"
+
+stamp="$out/.react-native-version"
+if [ "$(cat "$stamp" 2>/dev/null)" = "$rn_version" ]; then
+  exit 0
+fi
+rm -rf "$out"
+mkdir -p "$out" "$cache/downloads"
+
+fetch() {
+  local file="$cache/downloads/$1"
+  if [ ! -f "$file" ]; then
+    curl -fsSL "$2" -o "$file.part"
+    mv "$file.part" "$file"
+  fi
+  echo "$file"
+}
+
+work="$(mktemp -d)"
+trap 'rm -rf "$work"' EXIT
+
+# strips the archive's top directory, extracting only the matching members
+unpack() {
+  local tarball="$1" dest="$2"
+  shift 2
+  mkdir -p "$dest"
+  tar -xzf "$tarball" -C "$dest" --strip-components=1 "$@"
+}
+
+tarball="$(fetch "boost_$boost.tar.gz" "https://archives.boost.io/release/${boost//_/.}/source/boost_$boost.tar.gz")"
+unpack "$tarball" "$out/boost/boost_$boost" --wildcards "boost_$boost/boost"
+
+tarball="$(fetch "double-conversion-$double_conversion.tar.gz" "https://github.com/google/double-conversion/archive/v$double_conversion.tar.gz")"
+unpack "$tarball" "$work/double-conversion"
+mkdir -p "$out/double-conversion/double-conversion"
+cp "$work"/double-conversion/src/*.{cc,h} "$out/double-conversion/double-conversion/"
+cp "$jni/double-conversion/CMakeLists.txt" "$out/double-conversion/"
+
+tarball="$(fetch "folly-$folly.tar.gz" "https://github.com/facebook/folly/archive/v$folly.tar.gz")"
+unpack "$tarball" "$out/folly" --wildcards "folly-$folly/folly"
+cp "$jni/folly/CMakeLists.txt" "$out/folly/"
+
+tarball="$(fetch "fast_float-$fast_float.tar.gz" "https://github.com/fastfloat/fast_float/archive/v$fast_float.tar.gz")"
+unpack "$tarball" "$out/fast_float" --wildcards "fast_float-$fast_float/include"
+cp "$jni/fast_float/CMakeLists.txt" "$out/fast_float/"
+
+tarball="$(fetch "fmt-$fmt.tar.gz" "https://github.com/fmtlib/fmt/archive/$fmt.tar.gz")"
+unpack "$tarball" "$out/fmt" --wildcards "fmt-$fmt/src" "fmt-$fmt/include"
+cp "$jni/fmt/CMakeLists.txt" "$out/fmt/"
+
+# glog: the .h.in headers are configured with the tokens ReactAndroid's
+# PrepareGlogTask substitutes, and the public headers go to exported/glog
+tarball="$(fetch "glog-$glog.tar.gz" "https://github.com/google/glog/archive/v$glog.tar.gz")"
+unpack "$tarball" "$out/glog/glog-$glog" --wildcards "glog-$glog/src"
+cp "$jni/glog/CMakeLists.txt" "$jni/glog/config.h" "$out/glog/"
+for template in "$out"/glog/glog-"$glog"/src/glog/*.h.in; do
+  sed \
+    -e 's/@ac_cv_have_unistd_h@/1/g' \
+    -e 's/@ac_cv_have_stdint_h@/1/g' \
+    -e 's/@ac_cv_have_systypes_h@/1/g' \
+    -e 's/@ac_cv_have_inttypes_h@/1/g' \
+    -e 's/@ac_cv_have_libgflags@/0/g' \
+    -e 's/@ac_google_start_namespace@/namespace google {/g' \
+    -e 's/@ac_cv_have_uint16_t@/1/g' \
+    -e 's/@ac_cv_have_u_int16_t@/1/g' \
+    -e 's/@ac_cv_have___uint16@/0/g' \
+    -e 's/@ac_google_end_namespace@/}/g' \
+    -e 's/@ac_cv_have___builtin_expect@/1/g' \
+    -e 's/@ac_google_namespace@/google/g' \
+    -e 's/@ac_cv___attribute___noinline@/__attribute__ ((noinline))/g' \
+    -e 's/@ac_cv___attribute___noreturn@/__attribute__ ((noreturn))/g' \
+    -e 's/@ac_cv___attribute___printf_4_5@/__attribute__((__format__ (__printf__, 4, 5)))/g' \
+    "$template" > "${template%.in}"
+done
+mkdir -p "$out/glog/exported/glog"
+cp "$out"/glog/glog-"$glog"/src/glog/{stl_logging,logging,raw_logging,vlog_is_on,log_severity}.h "$out/glog/exported/glog/"
+# RN's CMakeLists compiles glog-$glog/src from the glog directory
+echo "$rn_version" > "$stamp"

package/linux/scripts/prepare-hermes.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+# Builds Hermes for Linux from source at the revision the installed
+# react-native pins (the same HERMES_VERSION_NAME the macOS build downloads as a
+# prebuilt tarball) into $1/destroot: include/{hermes,jsi}, lib/libhermesvm.so
+# and bin/hermesc. Reuses the destroot while the version and config match.
+#   RN_ROOT  node_modules/react-native
+set -euo pipefail
+
+here="$(cd "$(dirname "$0")" && pwd)"
+source "$here/cache.sh"
+
+out="$1"
+config="${2:-debug}"
+version="$(sed -n 's/^HERMES_VERSION_NAME=//p' "$RN_ROOT/sdks/hermes-engine/version.properties")"
+src="$cache/src/hermes-$version"
+
+stamp="$out/.hermes-version"
+key="$version-$config-$arch-static-icu74.2-pic"
+if [ -f "$out/destroot/lib/libhermesvm.so" ] && [ "$(cat "$stamp" 2>/dev/null)" = "$key" ]; then
+  exit 0
+fi
+
+icu="$cache/icu-74.2-pic-$arch"
+"$here/prepare-icu.sh" "$icu"
+
+if [ ! -d "$src" ]; then
+  mkdir -p "$cache/src"
+  git clone -q --depth 1 --branch "hermes-v$version" https://github.com/facebook/hermes.git "$src.part"
+  mv "$src.part" "$src"
+fi
+
+if [ "$config" = debug ]; then
+  build_type=Debug
+  debugger=ON
+else
+  build_type=Release
+  debugger=OFF
+fi
+
+# the options of react-native's build-apple-framework.sh that apply here; jsi
+# comes from react-native, as it does for every other platform
+# upstream's Linux hermesc uses static ICU; keep the VM shared and embed only ICU.
+cmake -G Ninja -S "$src" -B "$out/build" \
+  -U 'ICU_*' -DICU_ROOT="$icu/destroot" \
+  -DCMAKE_BUILD_TYPE="$build_type" \
+  -DHERMES_ENABLE_DEBUGGER="$debugger" \
+  -DHERMES_ENABLE_INTL=OFF \
+  -DHERMES_USE_STATIC_ICU=ON \
+  -DHERMES_ENABLE_TEST_SUITE=OFF \
+  -DHERMES_ENABLE_LIBFUZZER=OFF \
+  -DHERMES_ENABLE_FUZZILLI=OFF \
+  -DHERMES_BUILD_SHARED_JSI=OFF \
+  -DHERMES_RELEASE_VERSION="for RN $(rn_version)" \
+  -DJSI_DIR="$RN_ROOT/ReactCommon/jsi" >/dev/null
+ninja -C "$out/build" hermesvm hermesc
+
+rm -rf "$out/destroot"
+mkdir -p "$out/destroot/include/hermes/Public" "$out/destroot/include/hermes/cdp" "$out/destroot/lib" "$out/destroot/bin"
+cp "$src"/API/hermes/*.h "$out/destroot/include/hermes/"
+cp "$src"/API/hermes/cdp/*.h "$out/destroot/include/hermes/cdp/"
+cp "$src"/public/hermes/Public/*.h "$out/destroot/include/hermes/Public/"
+cp "$out/build/lib/libhermesvm.so" "$out/destroot/lib/"
+cp "$out/build/bin/hermesc" "$out/destroot/bin/"
+echo "$key" > "$stamp"

package/linux/scripts/prepare-icu.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# builds static PIC ICU for Hermes' shared library, cached per architecture.
+# Ubuntu's libicu-dev static archives are not compiled for shared-library use.
+set -euo pipefail
+
+here="$(cd "$(dirname "$0")" && pwd)"
+source "$here/cache.sh"
+
+out="$1"
+version=74.2
+key="$version-pic-$arch"
+stamp="$out/.icu-version"
+if [ -f "$out/destroot/lib/libicuuc.a" ] && [ "$(cat "$stamp" 2>/dev/null)" = "$key" ]; then
+  exit 0
+fi
+
+tarball="$cache/downloads/icu4c-${version//./_}-src.tgz"
+mkdir -p "$cache/downloads"
+if [ ! -f "$tarball" ]; then
+  curl -fsSL "https://github.com/unicode-org/icu/releases/download/release-${version//./-}/icu4c-${version//./_}-src.tgz" -o "$tarball.part"
+  mv "$tarball.part" "$tarball"
+fi
+echo "68db082212a96d6f53e35d60f47d38b962e9f9d207a74cfac78029ae8ff5e08c  $tarball" | sha256sum -c -
+
+src="$cache/src/icu-$version"
+if [ ! -d "$src" ]; then
+  mkdir -p "$src.part"
+  tar -xzf "$tarball" -C "$src.part" --strip-components=1
+  mv "$src.part" "$src"
+fi
+
+mkdir -p "$out/build"
+cd "$out/build"
+CFLAGS="${CFLAGS:-} -fPIC" CXXFLAGS="${CXXFLAGS:-} -fPIC" \
+  "$src/source/configure" --prefix="$out/destroot" --libdir="$out/destroot/lib" \
+    --disable-shared --enable-static --with-data-packaging=static \
+    --disable-tests --disable-samples --disable-extras
+make -j "$cores"
+make install
+echo "$key" > "$stamp"

package/linux/scripts/screenshot.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# runs the Linux host under headless sway and captures the first frame with RN text.
+# $1 executable, $2 output png, $3 window size (default 800x600), $4 optional bundle
+set -euo pipefail
+
+exe="$1"
+png="$2"
+bundle="${4:-}"
+work="$(mktemp -d)"
+export XDG_RUNTIME_DIR="$work"
+export WLR_BACKENDS=headless WLR_LIBINPUT_NO_DEVICES=1 WLR_RENDERER=pixman
+export GDK_BACKEND=wayland GSK_RENDERER=cairo ONE_LINUX_STARTUP_LOG=1
+
+# sway runs startup commands after its Wayland socket is ready.
+mkfifo "$work/ready"
+exec 3<>"$work/ready"
+cat > "$work/config" <<CONFIG
+output * mode ${3:-800x600}
+exec printf '%s\\n' "\$WAYLAND_DISPLAY" > "$work/ready"
+CONFIG
+sway -c "$work/config" >"$png.sway.log" 2>&1 &
+sway_pid=$!
+trap 'kill "$sway_pid" 2>/dev/null || true; wait "$sway_pid" 2>/dev/null || true; rm -rf "$work"' EXIT
+read -r -t 10 WAYLAND_DISPLAY <&3
+export WAYLAND_DISPLAY
+exec 3>&-
+
+python3 - "$exe" "$png" "$bundle" <<'PYTHON'
+import os
+import selectors
+import subprocess
+import sys
+import time
+
+exe, png, bundle = sys.argv[1:]
+app = subprocess.Popen([exe] + ([bundle] if bundle else []), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+try:
+    selector = selectors.DefaultSelector()
+    selector.register(app.stdout, selectors.EVENT_READ)
+    deadline = time.monotonic() + 30
+    output = b''
+    with open(png + '.app.log', 'wb') as log:
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0 or not selector.select(remaining):
+                raise RuntimeError('no frame with RN text within 30 seconds')
+            chunk = os.read(app.stdout.fileno(), 65536)
+            if not chunk:
+                raise RuntimeError(f'host exited before content paint: {app.wait()}')
+            log.write(chunk)
+            log.flush()
+            sys.stdout.buffer.write(chunk)
+            sys.stdout.buffer.flush()
+            output += chunk
+            if b'first frame with RN text painted\n' in output:
+                if app.poll() is not None:
+                    raise RuntimeError('host exited at content paint')
+                subprocess.run(['grim', png], check=True)
+                break
+finally:
+    app.terminate()
+    try:
+        app.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        app.kill()
+        app.wait()
+PYTHON

package/linux/smoke/main.cpp

@@ -0,0 +1,228 @@
+// headless smoke test of the Linux core: a ReactInstance on Hermes evaluates a
+// Hermes bytecode file, and a Scheduler registers the core component
+// descriptors. No window and no toolkit.
+#include <ReactCommon/RuntimeExecutor.h>
+#include <cxxreact/JSBigString.h>
+#include <cxxreact/MessageQueueThread.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#include <react/renderer/components/image/ImageComponentDescriptor.h>
+#include <react/renderer/components/root/RootComponentDescriptor.h>
+#include <react/renderer/components/scrollview/ScrollViewComponentDescriptor.h>
+#include <react/renderer/components/text/ParagraphComponentDescriptor.h>
+#include <react/renderer/components/text/RawTextComponentDescriptor.h>
+#include <react/renderer/components/text/TextComponentDescriptor.h>
+#include <react/renderer/components/textinput/platform/ios/react/renderer/components/iostextinput/TextInputComponentDescriptor.h>
+#include <react/renderer/components/view/ViewComponentDescriptor.h>
+#include <react/renderer/core/EventBeat.h>
+#include <react/renderer/imagemanager/ImageManager.h>
+#include <react/renderer/scheduler/Scheduler.h>
+#include <react/renderer/scheduler/SchedulerDelegate.h>
+#include <react/renderer/scheduler/SchedulerToolbox.h>
+#include <react/runtime/PlatformTimerRegistry.h>
+#include <react/runtime/ReactInstance.h>
+#include <react/runtime/TimerManager.h>
+#include <react/runtime/hermes/HermesInstance.h>
+#include <react/utils/ContextContainer.h>
+
+#include <chrono>
+#include <condition_variable>
+#include <cstdio>
+#include <deque>
+#include <future>
+#include <mutex>
+#include <thread>
+
+using namespace facebook;
+using namespace facebook::react;
+
+namespace {
+
+// one thread draining a queue, the serial contract the runtime expects
+class SmokeMessageQueueThread : public MessageQueueThread {
+ public:
+  SmokeMessageQueueThread() : thread_([this] { run(); }) {}
+  ~SmokeMessageQueueThread() override {
+    quitSynchronous();
+  }
+
+  void runOnQueue(std::function<void()> &&work) override {
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      if (quit_) {
+        return;
+      }
+      queue_.push_back(std::move(work));
+    }
+    wake_.notify_one();
+  }
+
+  void runOnQueueSync(std::function<void()> &&work) override {
+    if (std::this_thread::get_id() == thread_.get_id()) {
+      work();
+      return;
+    }
+    std::promise<void> done;
+    runOnQueue([&] {
+      work();
+      done.set_value();
+    });
+    done.get_future().wait();
+  }
+
+  void quitSynchronous() override {
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      if (quit_) {
+        return;
+      }
+      quit_ = true;
+    }
+    wake_.notify_one();
+    if (std::this_thread::get_id() != thread_.get_id()) {
+      thread_.join();
+    }
+  }
+
+ private:
+  void run() {
+    for (;;) {
+      std::function<void()> work;
+      {
+        std::unique_lock<std::mutex> lock(mutex_);
+        wake_.wait(lock, [this] { return quit_ || !queue_.empty(); });
+        if (queue_.empty()) {
+          return;
+        }
+        work = std::move(queue_.front());
+        queue_.pop_front();
+      }
+      work();
+    }
+  }
+
+  std::mutex mutex_;
+  std::condition_variable wake_;
+  std::deque<std::function<void()>> queue_;
+  bool quit_{false};
+  std::thread thread_;
+};
+
+class SmokeTimerRegistry : public PlatformTimerRegistry {
+ public:
+  void createTimer(uint32_t, double) override {}
+  void deleteTimer(uint32_t) override {}
+  void createRecurringTimer(uint32_t, double) override {}
+};
+
+class SmokeEventBeat : public EventBeat {
+ public:
+  using EventBeat::EventBeat;
+};
+
+class SmokeSchedulerDelegate final : public SchedulerDelegate {
+ public:
+  void schedulerDidFinishTransaction(const std::shared_ptr<const MountingCoordinator> &) override {}
+  void schedulerShouldRenderTransactions(const std::shared_ptr<const MountingCoordinator> &) override {}
+  void schedulerShouldMergeReactRevision(SurfaceId) override {}
+  void schedulerDidRequestPreliminaryViewAllocation(const ShadowNode &) override {}
+  void schedulerDidDispatchCommand(const ShadowView &, const std::string &, const folly::dynamic &) override {}
+  void schedulerDidSendAccessibilityEvent(const ShadowView &, const std::string &) override {}
+  void schedulerDidSetIsJSResponder(const ShadowView &, bool, bool) override {}
+  void schedulerShouldSynchronouslyUpdateViewOnUIThread(Tag, const folly::dynamic &) override {}
+  void schedulerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &) override {}
+  void schedulerDidCaptureViewSnapshot(Tag, SurfaceId) override {}
+  void schedulerDidSetViewSnapshot(Tag, Tag, SurfaceId) override {}
+  void schedulerDidClearPendingSnapshots() override {}
+};
+
+} // namespace
+
+int main(int argc, char **argv) {
+  if (argc != 2) {
+    std::fprintf(stderr, "usage: one-linux-smoke <bundle.hbc>\n");
+    return 2;
+  }
+
+  auto jsThread = std::make_shared<SmokeMessageQueueThread>();
+  auto timerRegistry = std::make_unique<SmokeTimerRegistry>();
+  auto timerManager = std::make_shared<TimerManager>(std::move(timerRegistry));
+
+  auto onJsError = [](jsi::Runtime &, const JsErrorHandler::ProcessedError &error) {
+    std::fprintf(stderr, "js error: %s\n", error.message.c_str());
+  };
+
+  auto instance = std::make_shared<ReactInstance>(
+      HermesInstance::createJSRuntime(nullptr, jsThread, false), jsThread, timerManager, onJsError);
+  timerManager->setRuntimeExecutor(instance->getBufferedRuntimeExecutor());
+
+  std::mutex mutex;
+  std::condition_variable evaluated;
+  bool done = false;
+  std::string result;
+
+  instance->initializeRuntime({}, [&](jsi::Runtime &runtime) {
+    runtime.global().setProperty(
+        runtime,
+        "smokeDone",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "smokeDone"),
+            2,
+            [&](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) -> jsi::Value {
+              std::lock_guard<std::mutex> lock(mutex);
+              result = std::to_string(args[0].asNumber()) + " " + args[1].asString(rt).utf8(rt);
+              done = true;
+              evaluated.notify_all();
+              return jsi::Value::undefined();
+            }));
+  });
+
+  auto registry = std::make_shared<ComponentDescriptorProviderRegistry>();
+  registry->add(concreteComponentDescriptorProvider<RootComponentDescriptor>());
+  registry->add(concreteComponentDescriptorProvider<ViewComponentDescriptor>());
+  registry->add(concreteComponentDescriptorProvider<ImageComponentDescriptor>());
+  registry->add(concreteComponentDescriptorProvider<TextInputComponentDescriptor>());
+  registry->add(concreteComponentDescriptorProvider<ScrollViewComponentDescriptor>());
+  registry->add(concreteComponentDescriptorProvider<ParagraphComponentDescriptor>());
+  registry->add(concreteComponentDescriptorProvider<TextComponentDescriptor>());
+  registry->add(concreteComponentDescriptorProvider<RawTextComponentDescriptor>());
+
+  auto contextContainer = std::make_shared<ContextContainer>();
+  contextContainer->insert(RuntimeSchedulerKey, std::weak_ptr<RuntimeScheduler>(instance->getRuntimeScheduler()));
+  contextContainer->insert("ImageManager", std::make_shared<ImageManager>(contextContainer));
+
+  auto runtimeScheduler = instance->getRuntimeScheduler();
+  SchedulerToolbox toolbox;
+  toolbox.contextContainer = contextContainer;
+  toolbox.componentRegistryFactory = [registry](
+                                         const EventDispatcher::Weak &eventDispatcher,
+                                         const std::shared_ptr<const ContextContainer> &container) {
+    return registry->createComponentDescriptorRegistry(
+        {.eventDispatcher = eventDispatcher, .contextContainer = container});
+  };
+  toolbox.runtimeExecutor = instance->getBufferedRuntimeExecutor();
+  toolbox.bridgelessBindingsExecutor = instance->getUnbufferedRuntimeExecutor();
+  toolbox.eventBeatFactory = [runtimeScheduler](std::shared_ptr<EventBeat::OwnerBox> ownerBox) {
+    return std::make_unique<SmokeEventBeat>(std::move(ownerBox), *runtimeScheduler);
+  };
+
+  SmokeSchedulerDelegate delegate;
+  auto scheduler = std::make_unique<Scheduler>(toolbox, nullptr, &delegate);
+  std::printf("scheduler created with %zu component descriptors\n", static_cast<size_t>(8));
+
+  instance->loadScript(JSBigFileString::fromPath(argv[1]), std::string("file://") + argv[1]);
+
+  std::unique_lock<std::mutex> lock(mutex);
+  if (!evaluated.wait_for(lock, std::chrono::seconds(10), [&] { return done; })) {
+    std::fprintf(stderr, "bytecode did not evaluate within 10 seconds\n");
+    return 1;
+  }
+  std::printf("hermes evaluated bytecode %s, smokeDone(%s)\n", argv[1], result.c_str());
+  lock.unlock();
+
+  scheduler.reset();
+  instance->unregisterFromInspector();
+  instance.reset();
+  jsThread->quitSynchronous();
+  return 0;
+}

package/linux/smoke/smoke.js

@@ -0,0 +1 @@
+smokeDone(6 * 7, typeof HermesInternal);