expo-modules-jsi 58.0.7 → 58.0.9

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

@@ -165,6 +165,8 @@ inline void collectGarbage(jsi::IRuntime &runtime, const std::string &cause) {
 // 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.
+// `JavaScriptValue.write(_:to:)` moves a uniquely referenced value's handle into the slot the same
+// way, through `emplaceMovedValue`.
 inline void emplaceUndefined(jsi::Value *_Nonnull slot) noexcept {
   ::new (slot) jsi::Value();
 }
@@ -181,6 +183,31 @@ inline void emplaceNumber(jsi::Value *_Nonnull slot, double value) noexcept {
   ::new (slot) jsi::Value(value);
 }
 
+/**
+ Moves the value at `source` into the engine's result slot. Placement new, like the `emplace*`
+ helpers above: the slot must hold a value that owns nothing. `source` is left holding a null
+ pointer, so destroying it afterwards releases nothing.
+ */
+inline void emplaceMovedValue(jsi::Value *_Nonnull slot, jsi::Value *_Nonnull source) noexcept {
+  ::new (slot) jsi::Value(std::move(*source));
+}
+
+/**
+ Creates a string value straight from UTF-8 bytes. The `jsi::String` returned by `createFromUtf8`
+ is moved into the value, so the engine allocates one handle. Going through `jsi::Value(runtime,
+ const jsi::String &)` from Swift instead clones the handle and then releases the original.
+ */
+inline jsi::Value createStringValueFromUtf8(jsi::IRuntime &runtime, const uint8_t *_Nonnull utf8, size_t length) {
+  return jsi::Value(jsi::String::createFromUtf8(runtime, utf8, length));
+}
+
+/**
+ Same as `createStringValueFromUtf8`, for bytes the caller knows to be ASCII.
+ */
+inline jsi::Value createStringValueFromAscii(jsi::IRuntime &runtime, const char *_Nonnull ascii, size_t length) {
+  return jsi::Value(jsi::String::createFromAscii(runtime, ascii, length));
+}
+
 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);
@@ -193,6 +220,47 @@ inline jsi::Value callFunctionWithThis(jsi::IRuntime &runtime, const jsi::Functi
   });
 }
 
+/**
+ Calls `defineProperty`, the runtime's `Object.defineProperty`, on `object` with a new descriptor that holds
+ `value` (when `hasValue` is set) and only the attributes that are `true`, like a descriptor built in
+ JavaScript. Taking the function and the descriptor keys from the caller lets it create them once per runtime,
+ and building the descriptor and the arguments here avoids a round trip through Swift for each of them.
+ */
+inline void defineProperty(
+  jsi::IRuntime &runtime,
+  const jsi::Function &defineProperty,
+  const jsi::PropNameID &configurableKey,
+  const jsi::PropNameID &enumerableKey,
+  const jsi::PropNameID &writableKey,
+  const jsi::PropNameID &valueKey,
+  const jsi::Object &object,
+  const uint8_t *_Nonnull nameUtf8,
+  size_t nameLength,
+  const jsi::Value &value,
+  bool hasValue,
+  bool writable,
+  bool enumerable,
+  bool configurable
+) {
+  expo::CppError::tryCatch(runtime, [&] {
+    jsi::Object descriptor(runtime);
+    if (configurable) {
+      descriptor.setProperty(runtime, configurableKey, true);
+    }
+    if (enumerable) {
+      descriptor.setProperty(runtime, enumerableKey, true);
+    }
+    if (writable) {
+      descriptor.setProperty(runtime, writableKey, true);
+    }
+    if (hasValue) {
+      descriptor.setProperty(runtime, valueKey, value);
+    }
+    defineProperty.call(runtime, object, jsi::String::createFromUtf8(runtime, nameUtf8, nameLength), descriptor);
+    return jsi::Value::undefined();
+  });
+}
+
 inline jsi::Value callAsConstructor(jsi::IRuntime &runtime, const jsi::Function &function, const jsi::Value *_Nullable args, size_t count) {
   return expo::CppError::tryCatch(runtime, [&] {
     return function.callAsConstructor(runtime, args, count);

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

@@ -44,21 +44,34 @@ private:
 
   std::atomic<int> refCount{1};
 
+  RuntimeScheduler(void *scheduler, ScheduleFn fn) noexcept
+      : nativeScheduler(scheduler), scheduleFn(fn) {}
+
+  RuntimeScheduler() noexcept {}
+
 public:
+  // Swift creates instances through the static `create` functions rather than the constructors.
+  // Annotating the constructors with `SWIFT_RETURNS_RETAINED` silences the Swift 6.4 "cannot infer
+  // ownership" warning, but Swift 6.2 rejects that annotation on a constructor as an error. Static
+  // functions returning a shared reference accept the annotation on every Swift version.
+
   /**
-   Constructs a scheduler bound to a host-provided native RuntimeScheduler.
+   Creates a scheduler bound to a host-provided native RuntimeScheduler.
    `scheduleTask` dispatches through `fn`, which the host implements against
    the real react::RuntimeScheduler.
    */
-  SWIFT_RETURNS_RETAINED RuntimeScheduler(void *scheduler, ScheduleFn fn) noexcept
-      : nativeScheduler(scheduler), scheduleFn(fn) {}
+  static RuntimeScheduler *create(void *scheduler, ScheduleFn fn) noexcept SWIFT_RETURNS_RETAINED {
+    return new RuntimeScheduler(scheduler, fn);
+  }
 
   /**
-   Constructs a no-op scheduler. Scheduled tasks run synchronously on the
+   Creates a no-op scheduler. Scheduled tasks run synchronously on the
    caller's thread — intended for standalone runtimes (e.g. tests) that have
    no React scheduler.
    */
-  SWIFT_RETURNS_RETAINED RuntimeScheduler() {}
+  static RuntimeScheduler *create() noexcept SWIFT_RETURNS_RETAINED {
+    return new RuntimeScheduler();
+  }
 
   RuntimeScheduler(const RuntimeScheduler &) = delete;
 

package/apple/Tests/JavaScriptCodableSetTests.swift

@@ -0,0 +1,115 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+@Suite("JavaScriptCodable+Set")
+@JavaScriptActor
+struct JavaScriptCodableSetTests {
+  let runtime = JavaScriptRuntime()
+
+  @Test
+  func `decodes a set of strings from a JS Set`() throws {
+    let decoded = try Set<String>.decode(runtime.eval("new Set(['a', 'b'])"), in: runtime)
+    #expect(decoded == ["a", "b"])
+  }
+
+  @Test
+  func `decodes a set from a subclass of Set`() throws {
+    let decoded = try Set<Int>.decode(runtime.eval("new (class extends Set {})([1, 2])"), in: runtime)
+    #expect(decoded == [1, 2])
+  }
+
+  @Test
+  func `arrayizes a non-set object into a single-element set`() throws {
+    let decoded = try Set<[String: Int]>.decode(runtime.eval("({ a: 1 })"), in: runtime)
+    #expect(decoded == [["a": 1]])
+  }
+
+  @Test
+  func `decoding many sets leaves no helper on the global object`() throws {
+    let runtime = JavaScriptRuntime()
+    for _ in 0..<100 {
+      _ = try Set<Int>.decode(runtime.eval("new Set([1, 2, 3])"), in: runtime)
+    }
+    // The only object the wrapper may leave on `globalThis` is the long-lived-objects anchor.
+    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 `decodes a set from an array, collapsing duplicates`() throws {
+    let decoded = try Set<Int>.decode(runtime.eval("[1, 2, 2, 3, 1]"), in: runtime)
+    #expect(decoded == [1, 2, 3])
+  }
+
+  @Test
+  func `arrayizes a non-array, non-set scalar into a set`() throws {
+    #expect(try Set<Int>.decode(runtime.eval("42"), in: runtime) == [42])
+  }
+
+  @Test
+  func `encodes a set to a JS Set`() throws {
+    let encoded = try Set<Int>.encode([1, 2, 3], in: runtime)
+    #expect(encoded.is("Set"))
+    let object = encoded.getObject()
+    #expect(object.getProperty("size").getInt() == 3)
+    #expect(try object.callFunction("has", arguments: 2).getBool() == true)
+    #expect(try object.callFunction("has", arguments: 4).getBool() == false)
+  }
+
+  @Test
+  func `round-trips a set of sets`() throws {
+    let value: Set<Set<String>> = [["a"], ["b", "c"]]
+    let encoded = try Set<Set<String>>.encode(value, in: runtime)
+    #expect(try Set<Set<String>>.decode(encoded, in: runtime) == value)
+  }
+
+  @Test
+  func `round-trips an empty set`() throws {
+    #expect(try Set<Int>.decode(runtime.eval("new Set()"), in: runtime) == [])
+    let encoded = try Set<Int>.encode([], in: runtime)
+    #expect(encoded.is("Set"))
+    #expect(encoded.getObject().getProperty("size").getInt() == 0)
+  }
+
+  @Test
+  func `set decode rejects an element of the wrong type`() throws {
+    #expect(throws: (any Error).self) {
+      try Set<Int>.decode(runtime.eval("new Set([1, 'a'])"), in: runtime)
+    }
+  }
+
+  @Test
+  func `set decode collapses distinct JS objects that decode to equal values`() throws {
+    // JS `Set` compares objects by reference, so it holds both objects; Swift compares the decoded
+    // dictionaries by value, so they collapse into one element.
+    let decoded = try Set<[String: Int]>.decode(runtime.eval("new Set([{ a: 1 }, { a: 1 }, { b: 2 }])"), in: runtime)
+    #expect(decoded == [["a": 1], ["b": 2]])
+  }
+
+  @Test
+  func `encodes a set of dictionaries to a JS Set of distinct objects`() throws {
+    let encoded = try Set<[String: Int]>.encode([["a": 1], ["b": 2]], in: runtime)
+    runtime.global().setProperty("encodedSet", value: encoded)
+    let summary = try runtime.eval(
+      "Array.from(encodedSet, (entry) => JSON.stringify(entry)).sort().join(',')"
+    )
+    #expect(summary.getString() == #"{"a":1},{"b":2}"#)
+  }
+
+  @Test
+  func `decodes a set argument and encodes a set result through a host function`() throws {
+    let fn = runtime.createFunction("uppercased") { [self] _, arguments in
+      let strings = try Set<String>.decode(arguments.unownedValue(at: 0), in: runtime)
+      return try Set<String>.encode(Set(strings.map { $0.uppercased() }), in: runtime)
+    }
+    runtime.global().setProperty("uppercased", value: fn.asValue())
+    let result = try runtime.eval(
+      "const result = uppercased(new Set(['a', 'b']))",
+      "result instanceof Set && result.size === 2 && result.has('A') && result.has('B')"
+    )
+    #expect(result.getBool() == true)
+  }
+}

package/apple/Tests/JavaScriptDecodableKindsTests.swift

@@ -0,0 +1,132 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Foundation
+import Testing
+
+@Suite("JavaScriptDecodable.decodableKinds")
+@JavaScriptActor
+struct JavaScriptDecodableKindsTests {
+  let runtime = JavaScriptRuntime()
+
+  /// One sample value of each JS type, keyed by the source that evaluates to it.
+  static let samples = [
+    "42", "1.5", "'text'", "true", "null", "undefined", "10n", "Symbol()", "({})", "[1]", "new Uint8Array(1)",
+    "(function () {})",
+  ]
+
+  // MARK: - JavaScriptValueKinds(of:)
+
+  @Test
+  func `reads the kind of every JS type from owning and unowned values`() throws {
+    let expected: [String: JavaScriptValueKinds] = [
+      "42": .number, "1.5": .number, "'text'": .string, "true": .bool, "null": .null,
+      "undefined": .undefined, "10n": .bigint, "Symbol()": .symbol, "({})": .object, "[1]": .object,
+      "new Uint8Array(1)": .object, "(function () {})": .object,
+    ]
+    for source in Self.samples {
+      let value = try runtime.eval(source)
+      #expect(JavaScriptValueKinds(of: value) == expected[source], "owning \(source)")
+
+      let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: value)
+      let unownedKind = JavaScriptValueKinds(of: buffer.unownedValue(at: 0))
+      #expect(unownedKind == expected[source], "unowned \(source)")
+    }
+  }
+
+  // MARK: - decodableKinds
+
+  /// Checks that `decodableKinds` contains the kind of exactly the `accepted` samples, and that `decode`
+  /// throws for every rejected one. A rejection must be definitive, because a union skips the case
+  /// without trying to decode it.
+  private func expectDecodableKinds<T: JavaScriptDecodable>(
+    _ type: T.Type,
+    accept accepted: Set<String>,
+    sourceLocation: SourceLocation = #_sourceLocation
+  ) throws {
+    for source in Self.samples {
+      let value = try runtime.eval(source)
+      let expected = accepted.contains(source)
+      #expect(
+        T.decodableKinds.contains(JavaScriptValueKinds(of: value)) == expected,
+        "\(source)",
+        sourceLocation: sourceLocation
+      )
+      if !expected {
+        #expect(throws: (any Error).self, "decode \(source)", sourceLocation: sourceLocation) {
+          _ = try T.decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  static let numbers: Set<String> = ["42", "1.5"]
+  static let objects: Set<String> = ["({})", "[1]", "new Uint8Array(1)", "(function () {})"]
+
+  @Test
+  func `Bool accepts only booleans`() throws {
+    try expectDecodableKinds(Bool.self, accept: ["true"])
+  }
+
+  @Test
+  func `String accepts only strings`() throws {
+    try expectDecodableKinds(String.self, accept: ["'text'"])
+  }
+
+  @Test
+  func `floating-point types accept only numbers`() throws {
+    try expectDecodableKinds(Double.self, accept: Self.numbers)
+    try expectDecodableKinds(Float.self, accept: Self.numbers)
+    try expectDecodableKinds(CGFloat.self, accept: Self.numbers)
+  }
+
+  @Test
+  func `narrow integer types accept only numbers`() throws {
+    try expectDecodableKinds(Int8.self, accept: Self.numbers)
+    try expectDecodableKinds(Int16.self, accept: Self.numbers)
+    try expectDecodableKinds(Int32.self, accept: Self.numbers)
+    try expectDecodableKinds(UInt8.self, accept: Self.numbers)
+    try expectDecodableKinds(UInt16.self, accept: Self.numbers)
+    try expectDecodableKinds(UInt32.self, accept: Self.numbers)
+  }
+
+  @Test
+  func `64-bit integer types accept numbers and bigints`() throws {
+    let accepted = Self.numbers.union(["10n"])
+    try expectDecodableKinds(Int.self, accept: accepted)
+    try expectDecodableKinds(Int64.self, accept: accepted)
+    try expectDecodableKinds(UInt.self, accept: accepted)
+    try expectDecodableKinds(UInt64.self, accept: accepted)
+  }
+
+  @Test
+  func `Optional accepts null, undefined and what the wrapped type accepts`() throws {
+    try expectDecodableKinds(String?.self, accept: ["'text'", "null", "undefined"])
+  }
+
+  @Test
+  func `Array accepts objects and what the element type accepts`() throws {
+    // A non-array value is decoded as a single-element array.
+    try expectDecodableKinds([String].self, accept: Self.objects.union(["'text'"]))
+  }
+
+  @Test
+  func `Dictionary accepts only objects`() throws {
+    try expectDecodableKinds([String: Int].self, accept: Self.objects)
+  }
+
+  @Test
+  func `Data accepts only objects`() throws {
+    try expectDecodableKinds(Data.self, accept: Self.objects)
+  }
+
+  @Test
+  func `Date accepts numbers, strings and objects`() throws {
+    try expectDecodableKinds(Date.self, accept: Self.numbers.union(["'text'"]).union(Self.objects))
+  }
+
+  @Test
+  func `JavaScriptValue accepts every value`() throws {
+    try expectDecodableKinds(JavaScriptValue.self, accept: Set(Self.samples))
+  }
+}

package/apple/Tests/JavaScriptRuntimeCacheTests.swift

@@ -0,0 +1,117 @@
+import ExpoModulesJSI
+import Testing
+
+private final class CachedBox {
+  let value: Int
+
+  init(_ value: Int) {
+    self.value = value
+  }
+}
+
+@Suite
+@JavaScriptActor
+struct JavaScriptRuntimeCacheTests {
+  let runtime = JavaScriptRuntime()
+
+  @Test
+  func `creates the value on first use and reuses it afterwards`() {
+    let key = JavaScriptRuntime.Cache.Key<CachedBox>()
+    var makeCount = 0
+
+    let first = runtime.cached(key) {
+      makeCount += 1
+      return CachedBox(1)
+    }
+    let second = runtime.cached(key) {
+      makeCount += 1
+      return CachedBox(2)
+    }
+
+    #expect(makeCount == 1)
+    #expect(first === second)
+    #expect(second.value == 1)
+  }
+
+  @Test
+  func `keys are independent`() {
+    let firstKey = JavaScriptRuntime.Cache.Key<CachedBox>()
+    let secondKey = JavaScriptRuntime.Cache.Key<CachedBox>()
+
+    #expect(runtime.cached(firstKey) { CachedBox(1) }.value == 1)
+    #expect(runtime.cached(secondKey) { CachedBox(2) }.value == 2)
+    #expect(runtime.cached(firstKey) { CachedBox(3) }.value == 1)
+  }
+
+  @Test
+  func `keys can be used in any order`() {
+    let keys = (0..<16).map { _ in JavaScriptRuntime.Cache.Key<CachedBox>() }
+
+    // Using the last key first grows the storage past all the others, which must then stay empty.
+    #expect(runtime.cached(keys[15]) { CachedBox(15) }.value == 15)
+    #expect(runtime.cached(keys[3]) { CachedBox(3) }.value == 3)
+    #expect(runtime.cached(keys[15]) { CachedBox(-1) }.value == 15)
+    #expect(runtime.cached(keys[0]) { CachedBox(0) }.value == 0)
+  }
+
+  @Test
+  func `each runtime has its own entries`() {
+    let key = JavaScriptRuntime.Cache.Key<CachedBox>()
+    let otherRuntime = JavaScriptRuntime()
+
+    #expect(runtime.cached(key) { CachedBox(1) }.value == 1)
+    #expect(otherRuntime.cached(key) { CachedBox(2) }.value == 2)
+  }
+
+  @Test
+  func `a value can be created from other cached values`() {
+    let baseKey = JavaScriptRuntime.Cache.Key<CachedBox>()
+    let derivedKey = JavaScriptRuntime.Cache.Key<CachedBox>()
+
+    // The nested lookup runs while the outer one is still creating its value.
+    let derived = runtime.cached(derivedKey) {
+      let base = runtime.cached(baseKey) { CachedBox(20) }
+      return CachedBox(base.value + 1)
+    }
+
+    #expect(derived.value == 21)
+    #expect(runtime.cached(baseKey) { CachedBox(0) }.value == 20)
+  }
+
+  @Test
+  func `a throwing make caches nothing`() throws {
+    struct MakeError: Error {}
+    let key = JavaScriptRuntime.Cache.Key<CachedBox>()
+
+    #expect(throws: MakeError.self) {
+      try runtime.cached(key) { throw MakeError() }
+    }
+    #expect(runtime.cached(key) { CachedBox(1) }.value == 1)
+  }
+
+  @Test
+  func `caches JavaScript values`() throws {
+    let key = JavaScriptRuntime.Cache.Key<JavaScriptValue>()
+
+    let first = try runtime.cached(key) { try runtime.eval("({ answer: 42 })") }
+    let second = try runtime.cached(key) { try runtime.eval("({ answer: 0 })") }
+
+    #expect(first === second)
+    #expect(second.getObject().getProperty("answer").getInt() == 42)
+  }
+
+  @Test
+  func `cached values are released with the runtime`() {
+    let key = JavaScriptRuntime.Cache.Key<CachedBox>()
+    weak var cachedValue: CachedBox?
+
+    do {
+      let runtime = JavaScriptRuntime()
+      cachedValue = runtime.cached(key) { CachedBox(1) }
+      #expect(cachedValue != nil)
+      withExtendedLifetime(runtime) {}
+    }
+
+    #expect(cachedValue == nil)
+  }
+}

package/apple/Tests/JavaScriptRuntimeTests.swift

@@ -34,6 +34,40 @@ struct JavaScriptRuntimeTests {
     #expect(fn.asValue().isFunction() == true)
   }
 
+  @Test
+  func `host function returns a fresh string`() throws {
+    let fn = runtime.createFunction("greet") { [runtime] _, _ in
+      return JavaScriptValue(runtime, "hello")
+    }
+    runtime.global().setProperty("greet", value: fn)
+    #expect(try runtime.eval("greet() + ' ' + greet()").getString() == "hello hello")
+  }
+
+  @Test
+  func `host function returns a shared value repeatedly`() throws {
+    // The same instance is returned on every call, so the host call must copy the engine handle
+    // instead of moving it out: the captured value has to stay valid for the next call.
+    let shared = JavaScriptValue(runtime, "shared")
+    let fn = runtime.createFunction("shared") { _, _ in
+      return shared
+    }
+    runtime.global().setProperty("shared", value: fn)
+    #expect(try runtime.eval("shared() + ' ' + shared()").getString() == "shared shared")
+    #expect(shared.getString() == "shared")
+  }
+
+  @Test
+  func `host function returns an object it keeps`() throws {
+    let kept = runtime.createObject()
+    kept.setProperty("answer", value: 42)
+    let fn = runtime.createFunction("kept") { _, _ in
+      return kept.asValue()
+    }
+    runtime.global().setProperty("kept", value: fn)
+    #expect(try runtime.eval("kept().answer + kept().answer").getInt() == 84)
+    #expect(kept.getProperty("answer").getInt() == 42)
+  }
+
   @Test
   func `evaluate script`() throws {
     #expect(try runtime.eval("'hello' + ' ' + 'world'").getString() == "hello world")
@@ -58,6 +92,23 @@ struct JavaScriptRuntimeTests {
     #expect(result.getString() == "hello")
   }
 
+  @Test
+  func `evaluate to promise on the JavaScript thread when called from another thread`() async throws {
+    // The test body runs on a cooperative thread, not on the scheduler's thread. Evaluating there
+    // would run JavaScript concurrently with the work the scheduler runs, such as settling a promise.
+    let testRuntime = await TestRuntimeScheduler().makeRuntime()
+    let runtime = testRuntime.runtime
+    try await testRuntime.scheduler.runIsolated {
+      let isOnJavaScriptThread = runtime.createFunction("isOnJavaScriptThread") { _, _ in
+        return JavaScriptValue(runtime, runtime.isOnJavaScriptThread())
+      }
+      runtime.global().setProperty("isOnJavaScriptThread", value: isOnJavaScriptThread.asValue())
+    }
+
+    let result = try await runtime.evalAsync("Promise.resolve(isOnJavaScriptThread())")
+    #expect(result.getBool() == true)
+  }
+
   @Test
   func `is equatable`() {
     #expect((runtime == runtime) == true)
@@ -136,11 +187,11 @@ struct JavaScriptRuntimeTests {
     }
 
     await scheduler.run {
-      nonisolated(unsafe) var didRunInline = false
+      let didRunInline = InlineRunFlag()
       runtime.runOrSchedule {
-        didRunInline = true
+        didRunInline.value = true
       }
-      #expect(didRunInline)
+      #expect(didRunInline.value)
     }
 
     await withCheckedContinuation { continuation in
@@ -217,6 +268,31 @@ struct JavaScriptRuntimeTests {
     #expect(hostObject.getProperty("unknown").isUndefined())
   }
 
+  @Test
+  func `host object getter returns strings`() throws {
+    // `fresh` is created per access and gets moved into the result; `shared` is the same instance on
+    // every access and has to be copied so it stays valid.
+    let shared = JavaScriptValue(runtime, "shared")
+    let hostObject = runtime.createHostObject(
+      get: { [runtime] name in
+        switch name {
+        case "fresh":
+          return JavaScriptValue(runtime, "fresh")
+        case "shared":
+          return shared
+        default:
+          return .undefined
+        }
+      },
+      getPropertyNames: { ["fresh", "shared"] }
+    )
+    runtime.global().setProperty("host", value: hostObject)
+
+    #expect(try runtime.eval("host.fresh + host.fresh").getString() == "freshfresh")
+    #expect(try runtime.eval("host.shared + host.shared").getString() == "sharedshared")
+    #expect(shared.getString() == "shared")
+  }
+
   @Test
   func `host object set property`() {
     var storedValue: Int?
@@ -1089,6 +1165,13 @@ struct JavaScriptRuntimeTests {
   }
 }
 
+/// Records whether a `runOrSchedule` block ran. A class instead of a `nonisolated(unsafe) var` captured
+/// by the block, which Swift 6.2 rejects as a data race. Safe without synchronization: the test only
+/// reads it after the block ran inline on the same thread.
+private final class InlineRunFlag: @unchecked Sendable {
+  var value = false
+}
+
 /// 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.