expo-modules-jsi 57.0.8 → 57.1.0

package/apple/Sources/ExpoModulesJSI/Runtime/Values/JavaScriptValue.swift

@@ -517,6 +517,24 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
     return copy()
   }
 
+  /// Writes this value into a host callback's result slot. Undefined, null, booleans and numbers are
+  /// emplaced with the engine's inline constructors, so the common results skip the out-of-line
+  /// `jsi::Value` move and destroy that assigning to the slot would cost; everything else is copied
+  /// through ``asJSIValue()``. The slot must hold a value with nothing to release (see `emplaceUndefined`).
+  internal func writeJSIValue(to slot: UnsafeMutablePointer<facebook.jsi.Value>) {
+    if pointee.isUndefined() {
+      expo.emplaceUndefined(slot)
+    } else if pointee.isNumber() {
+      expo.emplaceNumber(slot, pointee.getNumber())
+    } else if pointee.isBool() {
+      expo.emplaceBool(slot, pointee.getBool())
+    } else if pointee.isNull() {
+      expo.emplaceNull(slot)
+    } else {
+      slot.pointee = asJSIValue()
+    }
+  }
+
   internal func asJSIValue() -> facebook.jsi.Value {
     if let runtime {
       return facebook.jsi.Value(runtime.pointee, pointee)
@@ -615,21 +633,27 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
   // immutable and these carry no runtime and a trivial `jsi::Value`, so one instance can be safely
   // handed out from any isolation context. Every void-returning `@JS` function returns `.undefined`,
   // so a computed getter here would allocate on every host call.
-  private static let sharedUndefined = JavaScriptValue(nil, facebook.jsi.Value.undefined())
-  private static let sharedNull = JavaScriptValue(nil, facebook.jsi.Value.null())
+  //
+  // The instances live in the module-level globals below rather than in static properties: the
+  // `undefined` and `null` accessors are `@inlinable`, and an inlined body reaches a global through its
+  // addressor alone, whereas a class static, even a `@usableFromInline` one, goes through a getter
+  // that takes the class metatype, which costs the caller a metadata accessor call (`objc_opt_self`)
+  // on every access. Every void host function call accesses `undefined`.
 
   /// This is a lightweight way to create an undefined value that can be used in contexts
   /// where a runtime is not available or needed. The resulting value can be passed to
   /// JavaScript functions or used in comparisons.
+  @inlinable
   public static var undefined: JavaScriptValue {
-    return sharedUndefined
+    return sharedUndefinedValue
   }
 
   /// This is a lightweight way to create a null value that can be used in contexts
   /// where a runtime is not available or needed. The resulting value represents
   /// JavaScript's `null`, which is distinct from `undefined`.
+  @inlinable
   public static var null: JavaScriptValue {
-    return sharedNull
+    return sharedNullValue
   }
 
   /// This is a lightweight way to create a boolean true value that can be used in contexts
@@ -697,3 +721,10 @@ extension JavaScriptValue {
     }
   }
 }
+
+// Shared instances behind `JavaScriptValue.undefined` and `JavaScriptValue.null`; see the comment on
+// those accessors for why these are globals.
+@usableFromInline
+internal let sharedUndefinedValue = JavaScriptValue(nil, facebook.jsi.Value.undefined())
+@usableFromInline
+internal let sharedNullValue = JavaScriptValue(nil, facebook.jsi.Value.null())

package/apple/Sources/ExpoModulesJSI/Utilities/ErrorHandling.swift

@@ -32,40 +32,47 @@ internal func forwardingSwiftErrorsToJS(
 ) -> facebook.jsi.Value {
   do {
     return try body()
-  } catch let jsError as JavaScriptError {
-    // Relay the wrapped `jsi::JSError` directly so the thrown value reaches JS as-is, which may be
-    // an arbitrary value rather than an `Error` instance.
-    expo.CppError.setCurrent(jsError.toJSError())
-  } catch let throwable as JavaScriptThrowable {
-    expo.CppError.setCurrent(JavaScriptError(runtime, from: throwable).toJSError())
-  } catch let cppError as expo.CppError {
-    // Re-thrown by `capturingCppErrors` when nested JSI work raised a JS error; relay
-    // the original so its `jsi::JSError` (with stack, code, custom properties) survives.
-    expo.CppError.setCurrent(cppError)
-  } catch let error {
-    expo.CppError.setCurrent(runtime.pointee, std.string(String(describing: error)))
+  } catch {
+    storeSwiftError(error, runtime: runtime)
+    return .undefined()
   }
-  return .undefined()
 }
 
-/// Void overload of `forwardingSwiftErrorsToJS` for host object setter trampolines, which
-/// have no return value to propagate.
+/// Overload for trampolines that write their result into the caller's slot themselves. Returns
+/// whether an error was stored, so the C++ caller reads the thread-local error slot only then and
+/// skips the thread-local access on every successful call.
 @_transparent
 internal func forwardingSwiftErrorsToJS(
   runtime: JavaScriptRuntime,
   _ body: () throws -> Void
-) {
+) -> Bool {
   do {
     try body()
-  } catch let jsError as JavaScriptError {
+    return false
+  } catch {
+    storeSwiftError(error, runtime: runtime)
+    return true
+  }
+}
+
+/// Stores an error thrown by a host callback in `expo::CppError`'s thread-local slot for the C++
+/// side to rethrow as a `jsi::JSError`. Kept out of line on purpose: the trampolines above inline
+/// into every host callback, and with the error handling in their bodies the hot path carried the
+/// stack frame and register saves that only these branches need.
+@inline(never)
+internal func storeSwiftError(_ error: any Error, runtime: JavaScriptRuntime) {
+  switch error {
+  case let jsError as JavaScriptError:
     // Relay the wrapped `jsi::JSError` directly so the thrown value reaches JS as-is, which may be
     // an arbitrary value rather than an `Error` instance.
     expo.CppError.setCurrent(jsError.toJSError())
-  } catch let throwable as JavaScriptThrowable {
+  case let throwable as JavaScriptThrowable:
     expo.CppError.setCurrent(JavaScriptError(runtime, from: throwable).toJSError())
-  } catch let cppError as expo.CppError {
+  case let cppError as expo.CppError:
+    // Re-thrown by `capturingCppErrors` when nested JSI work raised a JS error; relay
+    // the original so its `jsi::JSError` (with stack, code, custom properties) survives.
     expo.CppError.setCurrent(cppError)
-  } catch let error {
+  default:
     expo.CppError.setCurrent(runtime.pointee, std.string(String(describing: error)))
   }
 }

package/apple/Sources/ExpoModulesJSI/Utilities/String+JSI.swift

@@ -17,7 +17,10 @@ extension String {
   internal init(jsiString: borrowing facebook.jsi.String, in runtime: facebook.jsi.IRuntime) {
     var result = ""
     withUnsafeMutablePointer(to: &result) { resultPtr in
-      runtime.getStringData(jsiString, UnsafeMutableRawPointer(resultPtr), appendEngineStringChunk)
+      // Goes through the `expo.getStringData` wrapper rather than the runtime method: on RN older
+      // than 0.86 (e.g. react-native-macos 0.81) `Runtime::getStringData` is protected, so Swift
+      // cannot call it directly.
+      expo.getStringData(runtime, jsiString, UnsafeMutableRawPointer(resultPtr), appendEngineStringChunk)
     }
     self = result
   }

package/apple/Sources/ExpoModulesJSI-Cxx/include/HostFunctionClosure.h

@@ -15,7 +15,9 @@ public:
   // The result travels through an out-parameter instead of a return value: the Swift side can then
   // write it straight into the caller's slot from inside its guaranteed-reference scope, with no
   // placeholder value to construct and no extra move of the `jsi::Value`.
-  using Closure = void(Context context, const facebook::jsi::Value *_Nonnull thisValue, const facebook::jsi::Value *_Nonnull args, size_t count, facebook::jsi::Value *_Nonnull result);
+  // Returns whether the Swift side stored an error in `CppError`'s thread-local slot. Reporting that
+  // through the return value spares the caller a thread-local read on every successful call.
+  using Closure = bool(Context context, const facebook::jsi::Value *_Nonnull thisValue, const facebook::jsi::Value *_Nonnull args, size_t count, facebook::jsi::Value *_Nonnull result);
 
   explicit HostFunctionClosure(Context context, Closure closure, Deallocator deallocator) : RetainedSwiftPointer(context, deallocator), _closure(closure) {};
 
@@ -26,8 +28,8 @@ public:
   /**
    Calls the Swift closure with given `this` value and arguments.
    */
-  inline void call(const facebook::jsi::Value &thisValue, const facebook::jsi::Value *_Nonnull args, size_t count, facebook::jsi::Value &result) const {
-    _closure(_context, &thisValue, args, count, &result);
+  inline bool call(const facebook::jsi::Value &thisValue, const facebook::jsi::Value *_Nonnull args, size_t count, facebook::jsi::Value &result) const {
+    return _closure(_context, &thisValue, args, count, &result);
   }
 
 private:

package/apple/Sources/ExpoModulesJSI-Cxx/include/HostObject.h

@@ -24,11 +24,12 @@ public:
 
   inline jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
     jsi::Value result;
-    _callbacks.get(name.utf8(runtime).c_str(), result);
     // If the Swift getter stored a pending error, rethrow its JSError directly
     // to preserve all properties (message, code, stack, etc.).
-    if (auto *error = CppError::getCurrent()) {
-      throw error->release();
+    if (_callbacks.get(name.utf8(runtime).c_str(), result)) {
+      if (auto *error = CppError::getCurrent()) {
+        throw error->release();
+      }
     }
     return result;
   }
@@ -38,9 +39,10 @@ public:
     // `jsi::JSError` directly and the `CppError` check below is never reached.
     // For writable host objects, a throwing Swift setter routes its error through
     // `CppError`'s thread-local slot, which we drain and rethrow here.
-    _callbacks.set(runtime, name.utf8(runtime).c_str(), value);
-    if (auto *error = CppError::getCurrent()) {
-      throw error->release();
+    if (_callbacks.set(runtime, name.utf8(runtime).c_str(), value)) {
+      if (auto *error = CppError::getCurrent()) {
+        throw error->release();
+      }
     }
   }
 

package/apple/Sources/ExpoModulesJSI-Cxx/include/HostObjectCallbacks.h

@@ -18,16 +18,18 @@ public:
   using PropNameIds = std::vector<facebook::jsi::PropNameID>;
   // The getter writes its result through an out-parameter, like `HostFunctionClosure`, so the
   // Swift side can fill the caller's slot from inside its guaranteed-reference scope.
-  using Getter = void(Context, const char *_Nonnull name, facebook::jsi::Value *_Nonnull result);
-  using Setter = void(Context, const char *_Nonnull name, void *_Nonnull value);
+  // Both return whether the Swift side stored an error in `CppError`'s thread-local slot, so the
+  // caller reads that slot only when needed.
+  using Getter = bool(Context, const char *_Nonnull name, facebook::jsi::Value *_Nonnull result);
+  using Setter = bool(Context, const char *_Nonnull name, void *_Nonnull value);
   using PropertyNamesGetter = PropNameIds(Context);
   using Deallocator = void(Context);
 
   explicit HostObjectCallbacks(Context context, Getter getter, Setter *_Nullable setter, PropertyNamesGetter propertyNamesGetter, Deallocator deallocator)
   : _context(context), _getter(getter), _setter(setter), _propertyNamesGetter(propertyNamesGetter), _deallocator(deallocator) {}
 
-  inline void get(const char *_Nonnull name, facebook::jsi::Value &result) const {
-    _getter(_context, name, &result);
+  inline bool get(const char *_Nonnull name, facebook::jsi::Value &result) const {
+    return _getter(_context, name, &result);
   }
 
   /**
@@ -39,7 +41,7 @@ public:
    JSI call frame above this on the stack; calling outside that context will surface
    the throw as an unhandled C++ exception.
    */
-  inline void set(facebook::jsi::Runtime &runtime, const char *_Nonnull name, const facebook::jsi::Value &value) const {
+  inline bool set(facebook::jsi::Runtime &runtime, const char *_Nonnull name, const facebook::jsi::Value &value) const {
     if (_setter == nullptr) {
       throw facebook::jsi::JSError(
         runtime,
@@ -48,7 +50,7 @@ public:
           "Pass a `set` closure to `createHostObject` to make this property writable."
       );
     }
-    _setter(_context, name, (void *)(&value));
+    return _setter(_context, name, (void *)(&value));
   }
 
   inline PropNameIds getPropertyNames() const {

package/apple/Sources/ExpoModulesJSI-Cxx/include/JSIUtils.h

@@ -1,8 +1,10 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
 #pragma once
+
 #ifdef __cplusplus
 
+#include <new>
 #include <TargetConditionals.h>
 
 // `jsi.h` only forward-declares `jsi::Instrumentation`.
@@ -103,12 +105,12 @@ inline jsi::Function createHostFunction(jsi::IRuntime &runtime, const jsi::PropN
   auto closurePtr = std::shared_ptr<HostFunctionClosure>(closure);
   return jsi::Function::createFromHostFunction(runtime, propName, 0, [closurePtr](jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *_Nonnull args, size_t count) -> jsi::Value {
     jsi::Value result;
-    closurePtr->call(thisValue, args, count, result);
-
     // If the Swift closure stored a pending error, rethrow its JSError directly
     // to preserve all properties (message, code, stack, etc.).
-    if (auto *error = CppError::getCurrent()) {
-      throw error->release();
+    if (closurePtr->call(thisValue, args, count, result)) {
+      if (auto *error = CppError::getCurrent()) {
+        throw error->release();
+      }
     }
     return result;
   });
@@ -152,6 +154,33 @@ inline void collectGarbage(jsi::IRuntime &runtime, const std::string &cause) {
   runtime.instrumentation().collectGarbage(cause);
 }
 
+// MARK: - Result slots
+
+// Construct a host callback's result in place in the engine's result slot. `::new (slot) T(...)` is
+// placement new: it runs the constructor on existing memory and allocates nothing. These `jsi::Value`
+// constructors are inline, so each helper is two stores, whereas a move-assignment into the slot
+// calls `Value::~Value()` and `Value::Value(Value&&)`, both out-of-line in the engine library.
+//
+// Placement new does not destroy the slot's previous contents, so the slot must hold a value that
+// owns nothing; an object or string there would leak its engine handle. Both callers,
+// `createHostFunction` and `HostObject::get`, pass a default-constructed slot. The Swift side picks
+// the helper by kind in `JavaScriptValue.writeJSIValue(to:)` and moves everything else.
+inline void emplaceUndefined(jsi::Value *_Nonnull slot) noexcept {
+  ::new (slot) jsi::Value();
+}
+
+inline void emplaceNull(jsi::Value *_Nonnull slot) noexcept {
+  ::new (slot) jsi::Value(nullptr);
+}
+
+inline void emplaceBool(jsi::Value *_Nonnull slot, bool value) noexcept {
+  ::new (slot) jsi::Value(value);
+}
+
+inline void emplaceNumber(jsi::Value *_Nonnull slot, double value) noexcept {
+  ::new (slot) jsi::Value(value);
+}
+
 inline jsi::Value callFunction(jsi::IRuntime &runtime, const jsi::Function &function, const jsi::Value *_Nullable args, size_t count) {
   return expo::CppError::tryCatch(runtime, [&] {
     return function.call(runtime, args, count);
@@ -170,6 +199,35 @@ inline jsi::Value callAsConstructor(jsi::IRuntime &runtime, const jsi::Function
   });
 }
 
+// MARK: - String
+
+/**
+ Invokes `callback` with the engine's internal representation of `string`, chunk by chunk
+ (see `jsi::Runtime::getStringData` docs). On RN 0.86+ the method is public on `IRuntime` and is
+ called directly. On older versions (e.g. react-native-macos 0.81) it is a protected member of
+ `jsi::Runtime`, which Swift cannot call, so this wrapper routes through the public
+ `jsi::String::getStringData` template helper instead. That adds one extra indirect call per chunk,
+ negligible next to the copy/transcode of the chunk itself.
+ The callback's pointer parameters mirror the unannotated `jsi.h` signature, so the same Swift
+ function can be passed to either.
+ */
+inline void getStringData(
+  jsi::IRuntime &runtime,
+  const jsi::String &string,
+  void *ctx,
+  void (*callback)(void *_Nullable ctx, bool ascii, const void *_Nullable data, size_t num)
+) {
+#if defined(REACT_NATIVE_VERSION_MAJOR) && defined(REACT_NATIVE_VERSION_MINOR) && \
+    (REACT_NATIVE_VERSION_MAJOR > 0 || REACT_NATIVE_VERSION_MINOR >= 86)
+  runtime.getStringData(string, ctx, callback);
+#else
+  auto forward = [ctx, callback](bool ascii, const void *data, size_t num) {
+    callback(ctx, ascii, data, num);
+  };
+  string.getStringData(runtime, forward);
+#endif
+}
+
 // MARK: - ArrayBuffer
 
 /**

package/apple/Tests/JavaScriptCodableTaskTests.swift

@@ -0,0 +1,116 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+// `Task.encode` settles its promise from a detached task, so the runtime here needs a real thread
+// for that settle to land on. A standalone `JavaScriptRuntime()` would run it inline on the
+// cooperative thread, concurrently with whatever the test body is doing to the same runtime. Every
+// call that touches the runtime runs through `runIsolated` for the same reason; `await()` itself is
+// a plain Swift suspension and resumes on the thread that settled the promise.
+@Suite("JavaScriptCodable+Task")
+struct JavaScriptCodableTaskTests {
+  @Test
+  func `encodes a task as a promise object`() async throws {
+    let runtime = await TestRuntimeScheduler().makeRuntime()
+    let promise = try await runtime.scheduler.runIsolated {
+      let task = Task<Int, any Error> {
+        return 42
+      }
+      let encoded = try Task.encode(task, in: runtime.runtime)
+      #expect(encoded.isObject())
+      return UncheckedSendable(value: try encoded.getPromise())
+    }
+    _ = try await promise.value.await()
+  }
+
+  @Test
+  func `resolves with the encoded success value`() async throws {
+    let runtime = await TestRuntimeScheduler().makeRuntime()
+    let promise = try await runtime.scheduler.runIsolated {
+      let task = Task<Int, any Error> {
+        return 42
+      }
+      return UncheckedSendable(value: try Task.encode(task, in: runtime.runtime).getPromise())
+    }
+    let result = try await promise.value.await()
+    #expect(result.getInt() == 42)
+  }
+
+  @Test
+  func `resolves with a value produced after suspension`() async throws {
+    let runtime = await TestRuntimeScheduler().makeRuntime()
+    let promise = try await runtime.scheduler.runIsolated {
+      let task = Task<String, any Error> {
+        try await Task.sleep(nanoseconds: 10_000_000) // 10ms
+        return "done"
+      }
+      return UncheckedSendable(value: try Task.encode(task, in: runtime.runtime).getPromise())
+    }
+    let result = try await promise.value.await()
+    #expect(result.getString() == "done")
+  }
+
+  @Test
+  func `rejects when the task throws`() async throws {
+    struct TestError: Error {}
+    let runtime = await TestRuntimeScheduler().makeRuntime()
+    let promise = try await runtime.scheduler.runIsolated {
+      let task = Task<Int, any Error> {
+        throw TestError()
+      }
+      return UncheckedSendable(value: try Task.encode(task, in: runtime.runtime).getPromise())
+    }
+    await #expect(throws: Error.self) {
+      try await promise.value.await()
+    }
+  }
+
+  @Test
+  func `encodes a non-throwing task`() async throws {
+    let runtime = await TestRuntimeScheduler().makeRuntime()
+    let promise = try await runtime.scheduler.runIsolated {
+      let task = Task<Int, Never> {
+        return 7
+      }
+      return UncheckedSendable(value: try Task.encode(task, in: runtime.runtime).getPromise())
+    }
+    let result = try await promise.value.await()
+    #expect(result.getInt() == 7)
+  }
+
+  @Test
+  func `encodes a task whose success is itself codable`() async throws {
+    let runtime = await TestRuntimeScheduler().makeRuntime()
+    let promise = try await runtime.scheduler.runIsolated {
+      let task = Task<[String: Int], any Error> {
+        return ["answer": 42]
+      }
+      return UncheckedSendable(value: try Task.encode(task, in: runtime.runtime).getPromise())
+    }
+    let result = try await promise.value.await()
+    #expect(result.getObject().getProperty("answer").getInt() == 42)
+  }
+
+  @Test
+  func `encodes a task nested inside a container`() async throws {
+    // The motivating case: a promise handed to JS as a *value* rather than a function's own return.
+    let runtime = await TestRuntimeScheduler().makeRuntime()
+    let promises = try await runtime.scheduler.runIsolated {
+      let tasks = [
+        Task<Int, any Error> { return 1 },
+        Task<Int, any Error> { return 2 },
+      ]
+      let array = try [Task<Int, any Error>].encode(tasks, in: runtime.runtime).getArray()
+      #expect(array.length == 2)
+      return [
+        UncheckedSendable(value: try array.getValue(at: 0).getPromise()),
+        UncheckedSendable(value: try array.getValue(at: 1).getPromise()),
+      ]
+    }
+    let first = try await promises[0].value.await()
+    let second = try await promises[1].value.await()
+    #expect(first.getInt() == 1)
+    #expect(second.getInt() == 2)
+  }
+}

package/apple/Tests/JavaScriptPromiseTests.swift

@@ -1,6 +1,16 @@
 import ExpoModulesJSI
+import Foundation
 import Testing
 
+/// A `JavaScriptEncodable` whose `encode` always throws, for exercising the encodable `resolve`'s
+/// encode-failure path.
+private struct FailingEncodable: JavaScriptEncodable {
+  struct EncodingError: Error {}
+  static func encode(_ value: FailingEncodable, in runtime: borrowing JavaScriptRuntime) throws -> JavaScriptValue {
+    throw EncodingError()
+  }
+}
+
 @Suite
 @JavaScriptActor
 struct JavaScriptPromiseTests {
@@ -12,6 +22,32 @@ struct JavaScriptPromiseTests {
     #expect(promise.isDeferred == true)
   }
 
+  @Test
+  func `deferred promises from separate runtimes settle independently`() async throws {
+    let first = JavaScriptRuntime()
+    let second = JavaScriptRuntime()
+    let firstPromise = try JavaScriptPromise(first)
+    let secondPromise = try JavaScriptPromise(second)
+    firstPromise.resolve(1.0)
+    secondPromise.resolve(2.0)
+    #expect(try await firstPromise.await().getDouble() == 1.0)
+    #expect(try await secondPromise.await().getDouble() == 2.0)
+  }
+
+  @Test
+  func `creating many deferred promises reuses one runtime-level helper`() throws {
+    let runtime = JavaScriptRuntime()
+    for _ in 0..<1_000 {
+      let promise = try JavaScriptPromise(runtime)
+      promise.resolve(42.0)
+    }
+    // The only object the wrapper may leave on `globalThis` is the long-lived-objects anchor; a
+    // per-promise helper leaking into the global scope would show up as extra own properties.
+    let ownGlobals = try runtime.eval("Object.getOwnPropertyNames(globalThis).length").getInt()
+    let freshGlobals = try JavaScriptRuntime().eval("Object.getOwnPropertyNames(globalThis).length").getInt()
+    #expect(ownGlobals - freshGlobals <= 1)
+  }
+
   @Test
   func `deferred promise construction throws when Promise constructor is unavailable`() throws {
     let runtime = JavaScriptRuntime()
@@ -33,6 +69,45 @@ struct JavaScriptPromiseTests {
     #expect(result.getInt() == 42)
   }
 
+  @Test
+  func `resolve with a both-conforming value keeps its representable type`() async throws {
+    // A 64-bit integer conforms to both `JavaScriptRepresentable` and `JavaScriptEncodable`. The
+    // encodable overload is disfavored, so it resolves through the representable path and stays a JS
+    // `number`, rather than encoding to a `bigint` (`Int64.encode`) or rejecting for exceeding the
+    // safe-integer range (`Int.encode`).
+    let runtime = JavaScriptRuntime()
+    let promise = try JavaScriptPromise(runtime)
+    promise.resolve(Int64(42))
+    let result = try await promise.await()
+    #expect(result.isNumber())
+    #expect(result.getInt() == 42)
+  }
+
+  @Test
+  func `resolve promise with an encodable-only value`() async throws {
+    // `Date` is `JavaScriptEncodable` but not `JavaScriptRepresentable`, so it can only settle the
+    // promise through the encodable overload. It encodes to a JS `Date`.
+    let runtime = JavaScriptRuntime()
+    let promise = try JavaScriptPromise(runtime)
+    let date = Date(timeIntervalSince1970: 1000)
+    promise.resolve(date)
+    let result = try await promise.await()
+    let milliseconds = try result.getObject().callFunction("getTime").asDouble()
+    #expect(milliseconds == 1_000_000)
+  }
+
+  @Test
+  func `resolve rejects the promise when encoding throws`() async throws {
+    // The encodable `resolve` encodes on the JavaScript thread; if that throws, the promise must
+    // reject with the thrown error rather than fulfill.
+    let runtime = JavaScriptRuntime()
+    let promise = try JavaScriptPromise(runtime)
+    promise.resolve(FailingEncodable())
+    await #expect(throws: Error.self) {
+      try await promise.await()
+    }
+  }
+
   @Test
   func `resolve promise with string`() async throws {
     let runtime = JavaScriptRuntime()

package/apple/Tests/JavaScriptRuntimeTests.swift

@@ -585,6 +585,19 @@ struct JavaScriptRuntimeTests {
     #expect(result.getInt() == 42)
   }
 
+  @Test
+  func `host function results of primitive kinds reach JavaScript unchanged`() throws {
+    runtime.global().setProperty("yes", value: runtime.createFunction("yes") { _, _ in .true() }.asValue())
+    runtime.global().setProperty("no", value: runtime.createFunction("no") { _, _ in .false() }.asValue())
+    runtime.global().setProperty("nothing", value: runtime.createFunction("nothing") { _, _ in .null }.asValue())
+    runtime.global().setProperty("half", value: runtime.createFunction("half") { _, _ in .number(0.5) }.asValue())
+    let result = try runtime.eval("[yes() === true, no() === false, nothing() === null, half() === 0.5]").getArray()
+    #expect(result[0].getBool() == true)
+    #expect(result[1].getBool() == true)
+    #expect(result[2].getBool() == true)
+    #expect(result[3].getBool() == true)
+  }
+
   // MARK: - Async functions
 
   @Test
@@ -858,6 +871,28 @@ struct JavaScriptRuntimeTests {
     #expect(runtime.longLivedObjects.count == 1)
   }
 
+  @Test
+  func `non-owning wrapper outliving its runtime does not destroy cached PropNameIDs against freed memory`() throws {
+    // A non-owning wrapper's `deinit` returns early, so its stored `propNameIdsRegistry` is
+    // destroyed whenever the wrapper deallocates. If the wrapper outlives its runtime (e.g. it is
+    // captured by a task abandoned on reload), the cached `jsi::PropNameID` destructors used to run
+    // against the freed Hermes runtime, a use-after-free. Now the teardown sweep flushes the
+    // registry on the JS thread while the runtime is still valid.
+    var wrapper: JavaScriptRuntime? = nil
+    do {
+      let baseRuntime = JavaScriptRuntime()
+      wrapper = baseRuntime.withUnsafePointee { JavaScriptRuntime(unsafePointer: $0) }
+      // Creating a promise populates the wrapper's registry with cached "Promise" and "then" IDs.
+      _ = try JavaScriptPromise(wrapper!)
+      // Leaving the scope destroys the Hermes runtime while the wrapper is still alive; its
+      // teardown sweep must flush the cached PropNameIDs before Hermes is destroyed.
+    }
+    // Deallocating the wrapper here must not touch the freed runtime. Reaching the end of the test
+    // without a crash is the assertion.
+    wrapper = nil
+    _ = wrapper
+  }
+
   // MARK: - Garbage collection
 
   @Test
@@ -888,6 +923,21 @@ struct JavaScriptRuntimeTests {
   }
 }
 
+/// Tasks captured by `holdSchedulerTask` instead of being executed, emulating a React
+/// `RuntimeScheduler` that is torn down with work still queued (the #47716 reload scenario).
+/// Safe without synchronization: the dispatch always runs synchronously on the test's thread.
+nonisolated(unsafe) private var heldSchedulerTasks: [() -> Void] = []
+
+/// A `dispatch` trampoline for `JavaScriptRuntime.init(unsafePointer:scheduler:dispatch:)` that
+/// holds the scheduled tasks instead of running them, so a test controls when (and whether) they
+/// are released. Matches `expo.RuntimeScheduler.ScheduleFn`.
+private let holdSchedulerTask:
+  @convention(c) (
+    UnsafeMutableRawPointer?, Int32, @escaping @convention(block) () -> Void
+  ) -> Void = { _, _, callback in
+    heldSchedulerTasks.append(callback)
+  }
+
 /// Runs `body` on a freshly spawned synchronous thread and bridges the result back into the
 /// async test. The thread has a real run loop, which the cross-thread `execute` path pumps.
 private func onSyncOffThread<R: Sendable>(