expo-modules-jsi 58.0.5 → 58.0.7

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

@@ -4,6 +4,7 @@
 
 #include <swift/bridging>
 #include <jsi/jsi.h>
+#include <string>
 
 #include "RetainedSwiftPointer.h"
 
@@ -20,16 +21,24 @@ public:
   // Swift side can fill the caller's slot from inside its guaranteed-reference scope.
   // 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 Getter = bool(Context, const facebook::jsi::PropNameID *_Nonnull name, facebook::jsi::Value *_Nonnull result);
+  using Setter = bool(Context, const facebook::jsi::PropNameID *_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)
+  explicit HostObjectCallbacks(Context context, Getter getter, Setter setter, PropertyNamesGetter propertyNamesGetter, Deallocator deallocator)
   : _context(context), _getter(getter), _setter(setter), _propertyNamesGetter(propertyNamesGetter), _deallocator(deallocator) {}
 
-  inline bool get(const char *_Nonnull name, facebook::jsi::Value &result) const {
-    return _getter(_context, name, &result);
+  /**
+   Creates callbacks for a read-only host object: assignment from JavaScript throws a `jsi::JSError`
+   without calling into Swift. A separate constructor rather than a nullable setter, because Swift can't
+   pass a function reference where an optional C function pointer is expected.
+   */
+  explicit HostObjectCallbacks(Context context, Getter getter, PropertyNamesGetter propertyNamesGetter, Deallocator deallocator)
+  : _context(context), _getter(getter), _setter(nullptr), _propertyNamesGetter(propertyNamesGetter), _deallocator(deallocator) {}
+
+  inline bool get(const facebook::jsi::PropNameID &name, facebook::jsi::Value &result) const {
+    return _getter(_context, &name, &result);
   }
 
   /**
@@ -41,16 +50,16 @@ public:
    JSI call frame above this on the stack; calling outside that context will surface
    the throw as an unhandled C++ exception.
    */
-  inline bool set(facebook::jsi::Runtime &runtime, const char *_Nonnull name, const facebook::jsi::Value &value) const {
+  inline bool set(facebook::jsi::Runtime &runtime, const facebook::jsi::PropNameID &name, const facebook::jsi::Value &value) const {
     if (_setter == nullptr) {
       throw facebook::jsi::JSError(
         runtime,
-        std::string("Cannot set property '") + name + "' on a read-only host object: "
+        std::string("Cannot set property '") + name.utf8(runtime) + "' on a read-only host object: "
           "no setter was provided when the host object was created. "
           "Pass a `set` closure to `createHostObject` to make this property writable."
       );
     }
-    return _setter(_context, name, (void *)(&value));
+    return _setter(_context, &name, (void *)(&value));
   }
 
   inline PropNameIds getPropertyNames() const {

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

@@ -228,6 +228,26 @@ inline void getStringData(
 #endif
 }
 
+/**
+ Same as `getStringData`, but for a `jsi::PropNameID`.
+ */
+inline void getPropNameIdData(
+  jsi::IRuntime &runtime,
+  const jsi::PropNameID &propNameId,
+  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.getPropNameIdData(propNameId, ctx, callback);
+#else
+  auto forward = [ctx, callback](bool ascii, const void *data, size_t num) {
+    callback(ctx, ascii, data, num);
+  };
+  propNameId.getPropNameIdData(runtime, forward);
+#endif
+}
+
 // MARK: - ArrayBuffer
 
 /**

package/apple/Tests/JavaScriptCodableAnyTests.swift

@@ -0,0 +1,531 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Foundation
+import Testing
+
+@Suite("JavaScriptCodable+Any")
+@JavaScriptActor
+struct JavaScriptCodableAnyTests {
+  let runtime = JavaScriptRuntime()
+
+  // MARK: - decodeAny
+
+  @Test
+  func `decodes primitives into their native types`() throws {
+    #expect(try JavaScriptValue.decodeAny(runtime.eval("true"), in: runtime) as? Bool == true)
+    #expect(try JavaScriptValue.decodeAny(runtime.eval("1.5"), in: runtime) as? Double == 1.5)
+    #expect(try JavaScriptValue.decodeAny(runtime.eval("'abc'"), in: runtime) as? String == "abc")
+  }
+
+  @Test
+  func `decodes numbers as doubles`() throws {
+    let decoded = try JavaScriptValue.decodeAny(runtime.eval("3"), in: runtime)
+    #expect(decoded is Double)
+    #expect(decoded as? Double == 3)
+  }
+
+  @Test
+  func `decodes null and undefined as nil`() throws {
+    #expect(try isNil(JavaScriptValue.decodeAny(runtime.eval("null"), in: runtime)))
+    #expect(try isNil(JavaScriptValue.decodeAny(runtime.eval("undefined"), in: runtime)))
+  }
+
+  @Test
+  func `decodes nested containers`() throws {
+    let decoded = try JavaScriptValue.decodeAny(
+      runtime.eval("({ list: [1, 'a', null], inner: { flag: false } })"),
+      in: runtime
+    )
+    let dictionary = try #require(decoded as? [String: Any])
+    let list = try #require(dictionary["list"] as? [Any])
+    let inner = try #require(dictionary["inner"] as? [String: Any])
+    #expect(list.count == 3)
+    #expect(list[0] as? Double == 1)
+    #expect(list[1] as? String == "a")
+    #expect(isNil(list[2]))
+    #expect(inner["flag"] as? Bool == false)
+  }
+
+  @Test
+  func `decodes from a borrowed value`() throws {
+    let buffer = try JavaScriptValuesBuffer.allocate(in: runtime, with: runtime.eval("({ a: 'x' })"))
+    let decoded = try JavaScriptValue.decodeAny(buffer.unownedValue(at: 0), in: runtime)
+    #expect((decoded as? [String: Any])?["a"] as? String == "x")
+  }
+
+  @Test
+  func `decodes a bigint within the Int64 range as Int64`() throws {
+    #expect(try JavaScriptValue.decodeAny(runtime.eval("42n"), in: runtime) as? Int64 == 42)
+  }
+
+  @Test
+  func `throws for a bigint outside the Int64 range`() throws {
+    #expect(throws: BigIntConversionError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("2n ** 64n"), in: runtime)
+    }
+  }
+
+  @Test
+  func `throws TypeError for a function`() throws {
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("(() => {})"), in: runtime)
+    }
+  }
+
+  @Test
+  func `throws TypeError for a symbol`() throws {
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("Symbol('s')"), in: runtime)
+    }
+  }
+
+  @Test
+  func `throws TypeError for a function nested in a container`() throws {
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAnyDictionary(runtime.eval("({ callback() {} })"), in: runtime)
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAnyArray(runtime.eval("[1, () => {}]"), in: runtime)
+    }
+  }
+
+  @Test
+  func `throws TypeError for a borrowed function`() throws {
+    let buffer = try JavaScriptValuesBuffer.allocate(in: runtime, with: runtime.eval("(() => {})"))
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(buffer.unownedValue(at: 0), in: runtime)
+    }
+  }
+
+  @Test
+  func `decodes a borrowed bigint as Int64`() throws {
+    let buffer = try JavaScriptValuesBuffer.allocate(in: runtime, with: runtime.eval("7n"))
+    let decoded = try JavaScriptValue.decodeAny(buffer.unownedValue(at: 0), in: runtime)
+    #expect(decoded as? Int64 == 7)
+  }
+
+  @Test
+  func `decodes a Date as Date`() throws {
+    let decoded = try JavaScriptValue.decodeAny(runtime.eval("({ at: new Date(1500) })"), in: runtime)
+    #expect((decoded as? [String: Any])?["at"] as? Date == Date(timeIntervalSince1970: 1.5))
+  }
+
+  @Test
+  func `decodes a borrowed Date as Date`() throws {
+    let buffer = try JavaScriptValuesBuffer.allocate(in: runtime, with: runtime.eval("new Date(1500)"))
+    let decoded = try JavaScriptValue.decodeAny(buffer.unownedValue(at: 0), in: runtime)
+    #expect(decoded as? Date == Date(timeIntervalSince1970: 1.5))
+  }
+
+  @Test
+  func `round-trips a Date through encode and decode`() throws {
+    let date = Date(timeIntervalSince1970: 2)
+    let decoded = try JavaScriptValue.decodeAny(JavaScriptValue.encodeAny(date, in: runtime), in: runtime)
+    #expect(decoded as? Date == date)
+  }
+
+  @Test
+  func `decodes a Map with string keys as a dictionary and a Set as an array of its elements`() throws {
+    let decoded = try JavaScriptValue.decodeAnyDictionary(
+      runtime.eval("({ map: new Map([['k', 1], ['n', { x: true }]]), set: new Set([1, 'two', [3]]) })"),
+      in: runtime
+    )
+    let map = try #require(decoded["map"] as? [String: Any])
+    #expect(map.count == 2)
+    #expect(map["k"] as? Double == 1)
+    #expect((map["n"] as? [String: Any])?["x"] as? Bool == true)
+    let set = try #require(decoded["set"] as? [Any])
+    try #require(set.count == 3)
+    #expect(set[0] as? Double == 1)
+    #expect(set[1] as? String == "two")
+    #expect((set[2] as? [Any])?.first as? Double == 3)
+  }
+
+  // An `undefined` value means "absent" in a `Map` too, the same as for an object property.
+  @Test
+  func `drops Map entries whose value is undefined`() throws {
+    let decoded = try JavaScriptValue.decodeAnyDictionary(
+      runtime.eval("new Map([['gone', undefined], ['kept', 1]])"),
+      in: runtime
+    )
+    #expect(Array(decoded.keys) == ["kept"])
+  }
+
+  @Test
+  func `throws TypeError for a Map with a key that isn't a string`() throws {
+    let error = #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("({ lookup: new Map([[1, 'one']]) })"), in: runtime)
+    }
+    #expect(error?.description.contains("path: lookup") == true)
+  }
+
+  @Test
+  func `names the path to an unrepresentable value inside a Map`() throws {
+    let error = #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("({ lookup: new Map([['k', () => {}]]) })"), in: runtime)
+    }
+    #expect(error?.description.contains("path: lookup.k") == true)
+  }
+
+  @Test
+  func `throws TypeError for a WeakMap, a WeakSet or a DataView`() throws {
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("({ cache: new WeakMap() })"), in: runtime)
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("[new WeakSet()]"), in: runtime)
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("({ view: new DataView(new ArrayBuffer(4)) })"), in: runtime)
+    }
+  }
+
+  // An `Error` keeps `message` and `stack` in non-enumerable properties, so only what the caller
+  // added is decoded. This pins the documented limit of decoding from enumerable own properties.
+  @Test
+  func `decodes an Error from its enumerable properties only`() throws {
+    let decoded = try JavaScriptValue.decodeAnyDictionary(
+      runtime.eval("const error = new Error('failed'); error.code = 'E_FAILED'; error"),
+      in: runtime
+    )
+    #expect(Array(decoded.keys) == ["code"])
+    #expect(decoded["code"] as? String == "E_FAILED")
+  }
+
+  @Test
+  func `throws TypeError for a typed array or an ArrayBuffer`() throws {
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("({ bytes: new Uint8Array(4) })"), in: runtime)
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("[new ArrayBuffer(4)]"), in: runtime)
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAnyDictionary(runtime.eval("new Float64Array(4)"), in: runtime)
+    }
+  }
+
+  @Test
+  func `throws TypeError for a cyclic value`() throws {
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAnyDictionary(
+        runtime.eval("const object = {}; object.self = object; object"),
+        in: runtime
+      )
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAnyArray(runtime.eval("const array = []; array.push(array); array"), in: runtime)
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("const set = new Set(); set.add(set); set"), in: runtime)
+    }
+  }
+
+  @Test
+  func `names the path to an unrepresentable value in the error`() throws {
+    let error = #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("({ user: { tags: ['a', () => {}] } })"), in: runtime)
+    }
+    #expect(error?.description.contains("user.tags[1]") == true)
+  }
+
+  // MARK: - decodeAnyArray
+
+  @Test
+  func `decodes an array of mixed values`() throws {
+    let decoded = try JavaScriptValue.decodeAnyArray(runtime.eval("[true, 2, 'three', [4]]"), in: runtime)
+    #expect(decoded.count == 4)
+    #expect(decoded[0] as? Bool == true)
+    #expect(decoded[1] as? Double == 2)
+    #expect(decoded[2] as? String == "three")
+    #expect((decoded[3] as? [Any])?.first as? Double == 4)
+  }
+
+  @Test
+  func `decodes undefined array elements as nil`() throws {
+    let decoded = try JavaScriptValue.decodeAnyArray(runtime.eval("[undefined, 1]"), in: runtime)
+    #expect(decoded.count == 2)
+    #expect(isNil(decoded[0]))
+  }
+
+  // A `Set` already decodes as an array of its elements, so it isn't wrapped like other non-array
+  // values. This matches `decodeAny(_:as: [Any].self)` and a `Set` nested inside a value.
+  @Test
+  func `decodes a top-level Set as its elements`() throws {
+    let decoded = try JavaScriptValue.decodeAnyArray(runtime.eval("new Set([1, 'two'])"), in: runtime)
+    try #require(decoded.count == 2)
+    #expect(decoded[0] as? Double == 1)
+    #expect(decoded[1] as? String == "two")
+  }
+
+  @Test
+  func `decodes a borrowed top-level Set as its elements`() throws {
+    let buffer = try JavaScriptValuesBuffer.allocate(in: runtime, with: runtime.eval("new Set([1, 'two'])"))
+    let decoded = try JavaScriptValue.decodeAnyArray(buffer.unownedValue(at: 0), in: runtime)
+    try #require(decoded.count == 2)
+    #expect(decoded[1] as? String == "two")
+  }
+
+  @Test
+  func `arrayizes a non-array value`() throws {
+    let decoded = try JavaScriptValue.decodeAnyArray(runtime.eval("'solo'"), in: runtime)
+    #expect(decoded.count == 1)
+    #expect(decoded[0] as? String == "solo")
+  }
+
+  @Test
+  func `decodes an array from a borrowed value`() throws {
+    let buffer = try JavaScriptValuesBuffer.allocate(in: runtime, with: runtime.eval("[1, 2]"))
+    let decoded = try JavaScriptValue.decodeAnyArray(buffer.unownedValue(at: 0), in: runtime)
+    #expect(decoded.compactMap { $0 as? Double } == [1, 2])
+  }
+
+  // MARK: - decodeAnyDictionary
+
+  @Test
+  func `decodes an object of mixed values`() throws {
+    let decoded = try JavaScriptValue.decodeAnyDictionary(runtime.eval("({ a: 1, b: 'two', c: null })"), in: runtime)
+    #expect(decoded.count == 3)
+    #expect(decoded["a"] as? Double == 1)
+    #expect(decoded["b"] as? String == "two")
+    #expect(decoded.keys.contains("c"))
+    #expect(isNil(decoded["c"]!))
+  }
+
+  @Test
+  func `drops undefined properties`() throws {
+    let decoded = try JavaScriptValue.decodeAnyDictionary(runtime.eval("({ a: undefined, b: 1 })"), in: runtime)
+    #expect(Array(decoded.keys) == ["b"])
+  }
+
+  @Test
+  func `throws TypeError for a non-object value`() throws {
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAnyDictionary(runtime.eval("42"), in: runtime)
+    }
+  }
+
+  // The dedicated dictionary path must treat a top-level value the same way as a nested one, and the
+  // same way as the generic `decodeAny(_:as: [String: Any].self)`.
+  @Test
+  func `decodes a top-level Map with string keys as a dictionary`() throws {
+    let decoded = try JavaScriptValue.decodeAnyDictionary(runtime.eval("new Map([['a', 1]])"), in: runtime)
+    #expect(decoded.count == 1)
+    #expect(decoded["a"] as? Double == 1)
+  }
+
+  @Test
+  func `decodes a borrowed top-level Map with string keys as a dictionary`() throws {
+    let buffer = try JavaScriptValuesBuffer.allocate(in: runtime, with: runtime.eval("new Map([['a', 1]])"))
+    let decoded = try JavaScriptValue.decodeAnyDictionary(buffer.unownedValue(at: 0), in: runtime)
+    #expect(decoded["a"] as? Double == 1)
+  }
+
+  @Test(arguments: [
+    "[1, 2]",
+    "new Date(0)",
+    "new Set([1])",
+    "(() => {})",
+    "new WeakMap()",
+    "new WeakSet()",
+    "new DataView(new ArrayBuffer(4))",
+    "new Map([[1, 'one']])",
+  ])
+  func `throws TypeError for a top-level value that isn't a dictionary`(source: String) throws {
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAnyDictionary(runtime.eval(source), in: runtime)
+    }
+  }
+
+  @Test
+  func `decodes an object from a borrowed value`() throws {
+    let buffer = try JavaScriptValuesBuffer.allocate(in: runtime, with: runtime.eval("({ k: true })"))
+    let decoded = try JavaScriptValue.decodeAnyDictionary(buffer.unownedValue(at: 0), in: runtime)
+    #expect(decoded["k"] as? Bool == true)
+  }
+
+  // MARK: - decodeAny(_:as:in:)
+
+  @Test
+  func `decodes a nested free-form type`() throws {
+    let decoded = try JavaScriptValue.decodeAny(runtime.eval("[[1], ['a', 'b']]"), as: [[Any]].self, in: runtime)
+    #expect(decoded.count == 2)
+    #expect(decoded[1].count == 2)
+    #expect(decoded[1][0] as? String == "a")
+  }
+
+  @Test
+  func `decodes null and undefined as nil for an optional type`() throws {
+    #expect(try JavaScriptValue.decodeAny(runtime.eval("null"), as: [String: [Any]]?.self, in: runtime) == nil)
+    #expect(try JavaScriptValue.decodeAny(runtime.eval("undefined"), as: [String: [Any]]?.self, in: runtime) == nil)
+  }
+
+  @Test
+  func `decodes a present value for an optional type`() throws {
+    let decoded = try JavaScriptValue.decodeAny(runtime.eval("({ a: [1] })"), as: [String: [Any]]?.self, in: runtime)
+    #expect(decoded?["a"]?.first as? Double == 1)
+  }
+
+  @Test
+  func `throws TypeError when the value doesn't match the type`() throws {
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("'text'"), as: [String: [Any]].self, in: runtime)
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("null"), as: [[Any]].self, in: runtime)
+    }
+  }
+
+  @Test
+  func `explains how free-form values decode when the cast fails`() throws {
+    let error = #expect(throws: JavaScriptValue.TypeError.self) {
+      try JavaScriptValue.decodeAny(runtime.eval("({ 1: 'one' })"), as: [Int: Any].self, in: runtime)
+    }
+    #expect(error?.description.contains("Double") == true)
+    #expect(error?.description.contains("String") == true)
+  }
+
+  @Test
+  func `decodes a nested null as nil for a nested optional`() throws {
+    let dictionary = try JavaScriptValue.decodeAny(
+      runtime.eval("({ a: null, b: [1] })"),
+      as: [String: [Any]?].self,
+      in: runtime
+    )
+    #expect(dictionary.keys.contains("a"))
+    #expect(dictionary["a"]! == nil)
+    #expect(dictionary["b"]??.first as? Double == 1)
+    let list = try JavaScriptValue.decodeAny(runtime.eval("[null, 1]"), as: [Any?].self, in: runtime)
+    #expect(list.count == 2)
+    #expect(list[0] == nil)
+    #expect(list[1] as? Double == 1)
+  }
+
+  // MARK: - encodeAny
+
+  @Test
+  func `encodes native primitives`() throws {
+    #expect(try JavaScriptValue.encodeAny("abc", in: runtime).getString() == "abc")
+    #expect(try JavaScriptValue.encodeAny(1.5, in: runtime).getDouble() == 1.5)
+    #expect(try JavaScriptValue.encodeAny(true, in: runtime).getBool() == true)
+    #expect(try JavaScriptValue.encodeAny(42, in: runtime).getInt() == 42)
+  }
+
+  @Test
+  func `throws for an Int outside the safe-integer range, like Int.encode`() throws {
+    #expect(throws: (any Error).self) {
+      try JavaScriptValue.encodeAny(9_007_199_254_740_993, in: runtime)
+    }
+    #expect(throws: (any Error).self) {
+      try JavaScriptValue.encodeAnyDictionary(["big": 9_007_199_254_740_993], in: runtime)
+    }
+  }
+
+  @Test
+  func `encodes boolean NSNumbers as booleans and other NSNumbers as numbers`() throws {
+    let yes = try JavaScriptValue.encodeAny(NSNumber(value: true), in: runtime)
+    let one = try JavaScriptValue.encodeAny(NSNumber(value: 1), in: runtime)
+    #expect(yes.isBool())
+    #expect(yes.getBool() == true)
+    #expect(one.isNumber())
+    #expect(one.getDouble() == 1)
+  }
+
+  @Test
+  func `encodes nil and NSNull as null`() throws {
+    let none: String? = nil
+    #expect(try JavaScriptValue.encodeAny(none as Any, in: runtime).isNull())
+    #expect(try JavaScriptValue.encodeAny(NSNull(), in: runtime).isNull())
+  }
+
+  @Test
+  func `encodes a present optional as its wrapped value`() throws {
+    let some: Any? = "wrapped"
+    #expect(try JavaScriptValue.encodeAny(some as Any, in: runtime).getString() == "wrapped")
+  }
+
+  @Test
+  func `encodes nested free-form containers`() throws {
+    let value: [[Any]] = [[1, "a"], [["k": true] as [String: Any]]]
+    let encoded = try JavaScriptValue.encodeAny(value, in: runtime)
+    runtime.global().setProperty("encoded", value: encoded)
+    #expect(try runtime.eval("JSON.stringify(encoded)").getString() == #"[[1,"a"],[{"k":true}]]"#)
+  }
+
+  @Test
+  func `encodes JavaScriptEncodable values`() throws {
+    let date = Date(timeIntervalSince1970: 1)
+    let encoded = try JavaScriptValue.encodeAny(date, in: runtime)
+    #expect(encoded.isObject())
+    #expect(try JavaScriptValue.encodeAny([1, 2] as [Int], in: runtime).getArray().length == 2)
+  }
+
+  @Test
+  func `round-trips a bigint through Int64`() throws {
+    let decoded = try JavaScriptValue.decodeAny(runtime.eval("9007199254740993n"), in: runtime)
+    let encoded = try JavaScriptValue.encodeAny(decoded, in: runtime)
+    try #require(encoded.isBigInt())
+    #expect(try encoded.getBigInt().asInt64() == 9_007_199_254_740_993)
+  }
+
+  @Test
+  func `passes a JavaScriptValue through`() throws {
+    let object = try runtime.eval("({ marker: 7 })")
+    let encoded = try JavaScriptValue.encodeAny(object, in: runtime)
+    #expect(encoded.getObject().getProperty("marker").getInt() == 7)
+  }
+
+  @Test
+  func `throws for a value with no JavaScript representation`() throws {
+    struct Opaque {}
+    #expect(throws: JavaScriptValue.EncodingError.self) {
+      try JavaScriptValue.encodeAny(Opaque(), in: runtime)
+    }
+  }
+
+  // MARK: - encodeAnyArray / encodeAnyDictionary
+
+  @Test
+  func `encodes an array of mixed values`() throws {
+    let encoded = try JavaScriptValue.encodeAnyArray([true, 2, "three", NSNull()], in: runtime)
+    runtime.global().setProperty("encoded", value: encoded)
+    #expect(try runtime.eval("JSON.stringify(encoded)").getString() == #"[true,2,"three",null]"#)
+  }
+
+  @Test
+  func `encodes a dictionary of mixed values`() throws {
+    let encoded = try JavaScriptValue.encodeAnyDictionary(["a": 1, "b": ["x", false] as [Any]], in: runtime)
+    let object = encoded.getObject()
+    #expect(object.getProperty("a").getInt() == 1)
+    runtime.global().setProperty("encoded", value: object.getProperty("b"))
+    #expect(try runtime.eval("JSON.stringify(encoded)").getString() == #"["x",false]"#)
+  }
+
+  @Test
+  func `round-trips a dictionary through decode and encode`() throws {
+    let decoded = try JavaScriptValue.decodeAnyDictionary(
+      runtime.eval("({ n: 1.5, s: 's', l: [true, null], o: { z: 0 } })"),
+      in: runtime
+    )
+    let encoded = try JavaScriptValue.encodeAnyDictionary(decoded, in: runtime)
+    runtime.global().setProperty("encoded", value: encoded)
+    #expect(
+      try runtime.eval("JSON.stringify(encoded, ['l', 'n', 'o', 's', 'z'])").getString()
+        == #"{"l":[true,null],"n":1.5,"o":{"z":0},"s":"s"}"#
+    )
+  }
+}
+
+/// True when a free-form value is `nil`, looking through any optionals it's boxed in (a decoded
+/// `null` is a `nil` boxed in `Any`, which `== nil` doesn't see).
+private func isNil(_ value: Any) -> Bool {
+  let mirror = Mirror(reflecting: value)
+  guard mirror.displayStyle == .optional else {
+    return false
+  }
+  guard let wrapped = mirror.children.first else {
+    return true
+  }
+  return isNil(wrapped.value)
+}

package/apple/Tests/JavaScriptRuntimeTests.swift

@@ -280,6 +280,46 @@ struct JavaScriptRuntimeTests {
     #expect(result.getString() == "hello")
   }
 
+  @Test
+  func `host object receives non-ASCII property names`() throws {
+    var receivedNames: [String] = []
+    var setNames: [String] = []
+
+    let hostObject = runtime.createHostObject(
+      get: { name in
+        receivedNames.append(name)
+        return .undefined
+      },
+      set: { name, _ in
+        setNames.append(name)
+      }
+    )
+
+    runtime.global().setProperty("hostObj", value: hostObject.asValue())
+    _ = try runtime.eval("globalThis.hostObj['właściwość']; globalThis.hostObj['🚀'] = 1")
+
+    #expect(receivedNames == ["właściwość"])
+    #expect(setNames == ["🚀"])
+  }
+
+  @Test
+  func `host object receives long property names`() throws {
+    var receivedName: String?
+    let longName = String(repeating: "a", count: 300)
+
+    let hostObject = runtime.createHostObject(
+      get: { name in
+        receivedName = name
+        return .undefined
+      }
+    )
+
+    runtime.global().setProperty("hostObj", value: hostObject.asValue())
+    _ = try runtime.eval("globalThis.hostObj['\(longName)']")
+
+    #expect(receivedName == longName)
+  }
+
   @Test
   func `isHostObject distinguishes host objects from plain ones`() {
     let hostObject = runtime.createHostObject(

package/apple/Tests/JavaScriptValueTests.swift

@@ -726,3 +726,21 @@ struct JavaScriptValueTests {
     #expect(pointee1 == pointee2)
   }
 }
+
+@Suite
+@JavaScriptActor
+struct JavaScriptValueRuntimeLifetimeTests {
+  @Test
+  func `runtime-free value kinds keep working after the runtime is gone`() throws {
+    var runtime: JavaScriptRuntime? = JavaScriptRuntime()
+    let bool = JavaScriptValue(runtime!, true)
+
+    // Values don't keep the runtime alive, so this deallocates it.
+    runtime = nil
+
+    // A boolean doesn't need the runtime, so these take the runtime-free paths instead of trapping.
+    #expect(try bool.jsonStringify() == "true")
+    #expect(bool.copy().getBool() == true)
+    #expect(bool.isEqual(to: .true()))
+  }
+}