expo-modules-jsi 58.0.7 → 58.0.9

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptCodable+Primitives.swift

@@ -15,6 +15,11 @@ import CoreGraphics
 // MARK: - Bool
 
 extension Bool: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .bool
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Bool
@@ -40,6 +45,11 @@ extension Bool: JavaScriptCodable {
 // MARK: - String
 
 extension String: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .string
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -74,6 +84,11 @@ extension String: JavaScriptCodable {
 // undefined behavior — a native crash, not a catchable error.
 
 extension Double: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -100,6 +115,11 @@ extension Double: JavaScriptCodable {
 }
 
 extension Float: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Float
@@ -123,6 +143,11 @@ extension Float: JavaScriptCodable {
 }
 
 extension CGFloat: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -170,6 +195,11 @@ extension CGFloat: JavaScriptCodable {
 // back, and a JS caller may pass either form.
 
 extension Int: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return [.number, .bigint]
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int {
@@ -192,6 +222,11 @@ extension Int: JavaScriptCodable {
 }
 
 extension Int8: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int8
@@ -215,6 +250,11 @@ extension Int8: JavaScriptCodable {
 }
 
 extension Int16: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int16
@@ -238,6 +278,11 @@ extension Int16: JavaScriptCodable {
 }
 
 extension Int32: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int32
@@ -261,6 +306,11 @@ extension Int32: JavaScriptCodable {
 }
 
 extension Int64: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return [.number, .bigint]
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int64
@@ -284,6 +334,11 @@ extension Int64: JavaScriptCodable {
 }
 
 extension UInt: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return [.number, .bigint]
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> UInt
@@ -307,6 +362,11 @@ extension UInt: JavaScriptCodable {
 }
 
 extension UInt8: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> UInt8
@@ -330,6 +390,11 @@ extension UInt8: JavaScriptCodable {
 }
 
 extension UInt16: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -356,6 +421,11 @@ extension UInt16: JavaScriptCodable {
 }
 
 extension UInt32: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -382,6 +452,11 @@ extension UInt32: JavaScriptCodable {
 }
 
 extension UInt64: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return [.number, .bigint]
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -407,13 +482,134 @@ extension UInt64: JavaScriptCodable {
   }
 }
 
+// MARK: - Integer conversion entry points
+
+// The inlinable integer witnesses call these non-generic overloads rather than the generic
+// implementations below. A client can devirtualize a witness and inline it only when its body calls
+// non-generic functions; through a generic, non-inlinable call, it falls back to dynamic dispatch, and a
+// direct call runs the generic implementation unspecialized. Each overload runs a copy of the generic
+// implementation specialized inside the framework.
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: Int8.Type) throws -> Int8 {
+  return try genericDecodeInteger(number, as: Int8.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: Int16.Type) throws -> Int16 {
+  return try genericDecodeInteger(number, as: Int16.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: Int32.Type) throws -> Int32 {
+  return try genericDecodeInteger(number, as: Int32.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: UInt8.Type) throws -> UInt8 {
+  return try genericDecodeInteger(number, as: UInt8.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: UInt16.Type) throws -> UInt16 {
+  return try genericDecodeInteger(number, as: UInt16.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: UInt32.Type) throws -> UInt32 {
+  return try genericDecodeInteger(number, as: UInt32.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(_ value: borrowing JavaScriptValue, as type: Int.Type) throws -> Int {
+  return try genericDecodeWideInteger(value, as: Int.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(
+  _ value: borrowing JavaScriptUnownedValue,
+  as type: Int.Type,
+  runtime: borrowing JavaScriptRuntime
+) throws -> Int {
+  return try genericDecodeWideInteger(value, as: Int.self, runtime: runtime)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(_ value: borrowing JavaScriptValue, as type: Int64.Type) throws -> Int64 {
+  return try genericDecodeWideInteger(value, as: Int64.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(
+  _ value: borrowing JavaScriptUnownedValue,
+  as type: Int64.Type,
+  runtime: borrowing JavaScriptRuntime
+) throws -> Int64 {
+  return try genericDecodeWideInteger(value, as: Int64.self, runtime: runtime)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(_ value: borrowing JavaScriptValue, as type: UInt.Type) throws -> UInt {
+  return try genericDecodeWideInteger(value, as: UInt.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(
+  _ value: borrowing JavaScriptUnownedValue,
+  as type: UInt.Type,
+  runtime: borrowing JavaScriptRuntime
+) throws -> UInt {
+  return try genericDecodeWideInteger(value, as: UInt.self, runtime: runtime)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(_ value: borrowing JavaScriptValue, as type: UInt64.Type) throws -> UInt64 {
+  return try genericDecodeWideInteger(value, as: UInt64.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(
+  _ value: borrowing JavaScriptUnownedValue,
+  as type: UInt64.Type,
+  runtime: borrowing JavaScriptRuntime
+) throws -> UInt64 {
+  return try genericDecodeWideInteger(value, as: UInt64.self, runtime: runtime)
+}
+
+@usableFromInline
+@JavaScriptActor
+func encodeSafeInteger(_ value: Int) throws -> JavaScriptValue {
+  return try genericEncodeSafeInteger(value)
+}
+
+@usableFromInline
+@JavaScriptActor
+func encodeSafeInteger(_ value: UInt) throws -> JavaScriptValue {
+  return try genericEncodeSafeInteger(value)
+}
+
+// MARK: - Generic integer conversions
+
 /// Rounds a JavaScript number to the nearest integer and narrows it to `T`, throwing instead of
 /// trapping when the value is non-finite or outside `T`'s representable range. `T(exactly:)` on the
 /// already-rounded value is nil only when out of range, sidestepping the lossy `Double(T.max)`
 /// boundary comparison for 64-bit widths.
-@usableFromInline
 @JavaScriptActor
-func decodeInteger<T: FixedWidthInteger>(_ number: Double, as type: T.Type) throws -> T {
+func genericDecodeInteger<T: FixedWidthInteger>(_ number: Double, as type: T.Type) throws -> T {
   guard number.isFinite, let result = T(exactly: number.rounded()) else {
     throw IntegerOutOfRangeException(value: number, type: "\(T.self)")
   }
@@ -424,47 +620,41 @@ func decodeInteger<T: FixedWidthInteger>(_ number: Double, as type: T.Type) thro
 /// case is checked first since it's the common one: a single `isNumber()` tag check, then the
 /// assert-only `getDouble()` reads the value without re-checking the tag. A `bigint` is read losslessly
 /// through its 64-bit accessor; anything else throws the same `TypeError` the `number` read would.
-@usableFromInline
 @JavaScriptActor
-func decodeWideInteger<T: FixedWidthInteger>(_ value: borrowing JavaScriptValue, as type: T.Type) throws -> T {
+func genericDecodeWideInteger<T: FixedWidthInteger>(_ value: borrowing JavaScriptValue, as type: T.Type) throws -> T {
   guard value.isNumber() else {
     guard value.isBigInt() else {
-      // Neither a number nor a bigint: `asDouble()` throws the canonical `TypeError`. Throwing it
-      // through the accessor (rather than constructing it here) keeps this inlinable helper from
-      // referencing `TypeError`'s internal memberwise initializer.
-      return try decodeInteger(value.asDouble(), as: T.self)
+      // Neither a number nor a bigint: `asDouble()` throws the canonical `TypeError`.
+      return try genericDecodeInteger(value.asDouble(), as: T.self)
     }
-    return try decodeBigInt(value.getBigInt(), as: T.self)
+    return try genericDecodeBigInt(value.getBigInt(), as: T.self)
   }
-  return try decodeInteger(value.getDouble(), as: T.self)
+  return try genericDecodeInteger(value.getDouble(), as: T.self)
 }
 
 /// `JavaScriptUnownedValue` overload of `decodeWideInteger`. The common `number` path stays zero-copy
 /// and pays a single tag check (see the owning overload); only a `bigint` materializes an owning value
 /// (the borrowed value exposes no BigInt accessor), which is acceptable on this rare branch.
-@usableFromInline
 @JavaScriptActor
-func decodeWideInteger<T: FixedWidthInteger>(
+func genericDecodeWideInteger<T: FixedWidthInteger>(
   _ value: borrowing JavaScriptUnownedValue,
   as type: T.Type,
   runtime: borrowing JavaScriptRuntime
 ) throws -> T {
   guard value.isNumber() else {
     guard value.isBigInt() else {
-      // See the owning overload: route the not-a-number throw through `asDouble()` rather than
-      // constructing `TypeError` here, which this inlinable helper can't reference.
-      return try decodeInteger(value.asDouble(), as: T.self)
+      // Neither a number nor a bigint: `asDouble()` throws the canonical `TypeError`.
+      return try genericDecodeInteger(value.asDouble(), as: T.self)
     }
-    return try decodeBigInt(value.copied(in: runtime).getBigInt(), as: T.self)
+    return try genericDecodeBigInt(value.copied(in: runtime).getBigInt(), as: T.self)
   }
-  return try decodeInteger(value.getDouble(), as: T.self)
+  return try genericDecodeInteger(value.getDouble(), as: T.self)
 }
 
 /// Narrows a `JavaScriptBigInt` to `T`, reading it through the signed or unsigned 64-bit accessor to
 /// match `T`'s signedness and throwing rather than truncating when it falls outside `T`'s range.
-@usableFromInline
 @JavaScriptActor
-func decodeBigInt<T: FixedWidthInteger>(_ bigInt: borrowing JavaScriptBigInt, as type: T.Type) throws -> T {
+func genericDecodeBigInt<T: FixedWidthInteger>(_ bigInt: borrowing JavaScriptBigInt, as type: T.Type) throws -> T {
   let wide: T? =
     if T.isSigned {
       bigInt.isInt64() ? T(exactly: bigInt.getInt64()) : nil
@@ -480,9 +670,8 @@ func decodeBigInt<T: FixedWidthInteger>(_ bigInt: borrowing JavaScriptBigInt, as
 /// Encodes a 64-bit-wide integer to a JS `number`, throwing when it falls outside JavaScript's
 /// safe-integer range where a `Double` could no longer represent it exactly. Used by `Int`/`UInt`,
 /// whose JS mapping stays a `number`; the explicitly-sized 64-bit types encode as a `bigint` instead.
-@usableFromInline
 @JavaScriptActor
-func encodeSafeInteger<T: FixedWidthInteger>(_ value: T) throws -> JavaScriptValue {
+func genericEncodeSafeInteger<T: FixedWidthInteger>(_ value: T) throws -> JavaScriptValue {
   // `Number.MAX_SAFE_INTEGER` (2^53 - 1): the largest magnitude where every integer up to it, and the
   // next one, is representable as a JS number. 2^53 itself is representable but unsafe (it collides with
   // 2^53 + 1), so the bound is exclusive above this. Used by `Int`/`UInt`, both 64-bit, so 2^53 fits.

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptCodable+Set.swift

@@ -0,0 +1,79 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+internal import ExpoModulesJSI_Cxx
+internal import jsi
+
+// `Set` encodes to a JS `Set` and decodes from a JS `Set` or, like `Array`, from an array or an arrayized
+// scalar. JSI has no `Set` API, so the conversions go through the runtime's global `Set` and `Array`
+// constructors. Equality differs between the two sides: a JS `Set` compares objects by reference while
+// a Swift `Set` compares by `Hashable`, so two distinct JS objects that decode to equal values collapse
+// into a single element.
+
+extension Set: JavaScriptDecodable where Element: JavaScriptDecodable {
+  @JavaScriptActor
+  @inlinable
+  public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
+    -> Set<Element>
+  {
+    // The cheap tag checks come first: an array takes the `Array` path directly, and a primitive
+    // can't be a JS `Set`, so both skip the JS call below. Any other value that is not a JS `Set` is
+    // arrayized, as in `Array`. Duplicates in an array collapse without an error.
+    guard !value.isArray(), value.isObject(), let entries = try runtime.setEntries(of: value) else {
+      return Set(try [Element].decode(value, in: runtime))
+    }
+    return Set(try [Element].decode(entries, in: runtime))
+  }
+}
+
+extension Set: JavaScriptEncodable where Element: JavaScriptEncodable {
+  @JavaScriptActor
+  @inlinable
+  public static func encode(_ value: Set<Element>, in runtime: borrowing JavaScriptRuntime) throws
+    -> JavaScriptValue
+  {
+    // Constructing from an array fills the set in a single call, rather than one `add` call per element.
+    let entries = try [Element].encode(Array(value), in: runtime)
+    return try runtime.setConstructor().callAsConstructor(entries)
+  }
+}
+
+extension JavaScriptRuntime {
+  /// Copies the entries of a JS `Set` out into a JS array, or returns `nil` when the value is not a
+  /// JS `Set`. The instance check and the copy run in a single call to a cached JS function, which
+  /// saves the global lookups and the separate `instanceof` call of `value.is("Set")` followed by
+  /// `Array.from`. For a small `Set` those fixed costs are most of the decode time.
+  @usableFromInline
+  @JavaScriptActor
+  func setEntries(of value: borrowing JavaScriptValue) throws -> JavaScriptValue? {
+    let function = try cached(setEntriesFunctionKey) {
+      return try eval(
+        label: "expo-modules-jsi/set-entries.js",
+        "(function (value) { return value instanceof Set ? Array.from(value) : undefined; })"
+      )
+    }
+    let setEntries = function.getFunction()
+    // Pass the borrowed `jsi::Value` straight to the call, rather than copying it into an owned value
+    // and again into an arguments buffer.
+    let entries = try withUnsafePointer(to: value.pointee) { argument in
+      return try capturingCppErrors {
+        return JavaScriptValue(self, expo.callFunction(pointee, setEntries.pointee, argument, 1))
+      }
+    }
+    return entries.isUndefined() ? nil : entries
+  }
+
+  /// Returns the global `Set` constructor, looked up once and cached, so an encode doesn't pay for
+  /// the global property lookup.
+  @usableFromInline
+  @JavaScriptActor
+  func setConstructor() throws -> JavaScriptFunction {
+    let constructor = try cached(setConstructorKey) {
+      return try global().getPropertyAsFunction("Set").asValue()
+    }
+    return constructor.getFunction()
+  }
+}
+
+/// Keys of the `Set` entries function and the `Set` constructor in each runtime's cache.
+private let setEntriesFunctionKey = JavaScriptRuntime.Cache.Key<JavaScriptValue>()
+private let setConstructorKey = JavaScriptRuntime.Cache.Key<JavaScriptValue>()

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptDecodable.swift

@@ -13,9 +13,10 @@
 public protocol JavaScriptDecodable {
   /// Decodes an owning `JavaScriptValue` into `Self`.
   ///
-  /// This overload is the protocol requirement: every conformer provides it. It is also the
-  /// correct entry point for any value that must outlive the call (stored, captured, handed to a
-  /// `Promise`).
+  /// Defaulted (see the extension below) to borrow the value and decode it through the
+  /// `JavaScriptUnownedValue` overload, so a conformer may implement just that one. A conformer must
+  /// implement at least one of the two overloads: each default forwards to the other, so with neither
+  /// implemented a decode recurses until the stack overflows.
   @JavaScriptActor
   static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Self
 
@@ -24,13 +25,35 @@ public protocol JavaScriptDecodable {
   ///
   /// This is the argument-decode fast path: the value borrows the argument the
   /// `JavaScriptValuesBuffer` already owns for the duration of the call. It is defaulted (see the
-  /// extension below), so conformers get it for free by materializing an owning value; types that
-  /// can read straight from the borrowed value override it to stay zero-copy.
+  /// extension below) to materialize an owning value and decode that, for conformers that implement
+  /// only the owning overload; types that can read straight from the borrowed value implement it to
+  /// stay zero-copy.
   @JavaScriptActor
   static func decode(_ value: borrowing JavaScriptUnownedValue, in runtime: borrowing JavaScriptRuntime) throws -> Self
+
+  /// The kinds of JavaScript value `decode` can accept.
+  ///
+  /// A kind outside the set is definitive: `decode` would throw for a value of that kind. A kind in the
+  /// set only means the type may decode it, so `decode` can still throw, for example for an
+  /// out-of-range number or a missing record field. Code that picks between several types, like a
+  /// union, reads it to skip the ones that can't match without paying for a thrown error. Defaults to
+  /// `.all`, so a type that doesn't declare it is always tried.
+  static var decodableKinds: JavaScriptValueKinds { get }
 }
 
 extension JavaScriptDecodable {
+  /// Default owning decode: borrow the value and forward to the unowned overload, so a conformer that
+  /// implements only that one decodes owning values without a copy.
+  @JavaScriptActor
+  @inlinable
+  public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Self
+  {
+    let runtime = copy runtime
+    return try value.withUnownedValue(in: runtime) { unownedValue in
+      return try decode(unownedValue, in: runtime)
+    }
+  }
+
   /// Default fast-path implementation: materialize an owning value and forward to the requirement.
   /// This is the "explicitly copy" behavior for types that cannot (or need not) read directly from
   /// the borrowed value.
@@ -44,4 +67,10 @@ extension JavaScriptDecodable {
   {
     return try decode(value.copied(in: runtime), in: runtime)
   }
+
+  /// Default: every kind, so a conformer that doesn't declare its kinds is always tried.
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .all
+  }
 }

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptValueKinds.swift

@@ -0,0 +1,73 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+internal import jsi
+
+/// A set of JavaScript value kinds, as told apart by the value's type tag alone.
+///
+/// Unlike `JavaScriptValue.Kind`, a function is an `object` here: telling it apart needs a call into
+/// the runtime, while every kind in this set is read from the tag without one. Used by
+/// `JavaScriptDecodable.decodableKinds` to describe the kinds a type can decode from. Frozen, so a check
+/// against it compiles to a mask test in the client.
+@frozen
+public struct JavaScriptValueKinds: OptionSet, Sendable {
+  public let rawValue: UInt16
+
+  // `UInt16` leaves room for more kinds without changing the frozen layout.
+  //
+  // The kinds are computed and inlinable rather than stored `static let`s, which a client would reach
+  // through a lazily initialized global, so a mask built from them folds to a constant.
+
+  @inlinable
+  public init(rawValue: UInt16) {
+    self.rawValue = rawValue
+  }
+
+  @inlinable public static var undefined: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 0) }
+  @inlinable public static var null: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 1) }
+  @inlinable public static var bool: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 2) }
+  @inlinable public static var number: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 3) }
+  @inlinable public static var bigint: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 4) }
+  @inlinable public static var string: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 5) }
+  @inlinable public static var symbol: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 6) }
+  /// Any object, including arrays, typed arrays and functions.
+  @inlinable public static var object: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 7) }
+
+  /// Every kind, including any added later: the bits above the current kinds are set too, so a type that
+  /// accepts every kind keeps doing so.
+  @inlinable public static var all: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: .max) }
+
+  /// The kind of `value`.
+  ///
+  /// Not inlinable on purpose: the type checks read the `jsi::Value`, which clients can't see, so an
+  /// inlined initializer would make one call into this module per check. Here it is a single call.
+  public init(of value: borrowing JavaScriptValue) {
+    self.init(of: value.pointee)
+  }
+
+  /// The kind of the borrowed `value`, read the same way as from an owning value.
+  public init(of value: borrowing JavaScriptUnownedValue) {
+    self.init(of: value.pointer.pointee)
+  }
+
+  /// Reads the kind from the `jsi::Value` both public initializers wrap. The checks go from the most to
+  /// the least common kind of an argument.
+  private init(of value: borrowing facebook.jsi.Value) {
+    if value.isNumber() {
+      self = .number
+    } else if value.isString() {
+      self = .string
+    } else if value.isObject() {
+      self = .object
+    } else if value.isBool() {
+      self = .bool
+    } else if value.isNull() {
+      self = .null
+    } else if value.isUndefined() {
+      self = .undefined
+    } else if value.isBigInt() {
+      self = .bigint
+    } else {
+      self = .symbol
+    }
+  }
+}

package/apple/Sources/ExpoModulesJSI/Protocols/JSIRepresentable.swift

@@ -93,14 +93,16 @@ extension String: JSIRepresentable {
     // allocation, copy and free per string. `withUTF8` is mutating (it makes a bridged string
     // contiguous first), hence the local copy; native strings are already contiguous and pay nothing.
     // The value is moved out through a local because `withUTF8` needs a `Copyable` closure result.
+    // The C++ helper moves the engine's `jsi::String` into the value, so this costs one engine handle;
+    // `jsi::Value(runtime, string)` would clone it and then release the original.
     var string = self
     var value = facebook.jsi.Value.undefined()
     string.withUTF8 { utf8 in
       guard let base = utf8.baseAddress else {
-        value = facebook.jsi.Value(runtime, facebook.jsi.String.createFromAscii(runtime, "", 0))
+        value = expo.createStringValueFromAscii(runtime, "", 0)
         return
       }
-      value = facebook.jsi.Value(runtime, facebook.jsi.String.createFromUtf8(runtime, base, utf8.count))
+      value = expo.createStringValueFromUtf8(runtime, base, utf8.count)
     }
     return value
   }