expo-modules-core 56.0.5 → 56.0.7

package/ios/Core/JSValueEncoder.swift

@@ -3,12 +3,21 @@
 import ExpoModulesJSI
 
 /**
- Encodes `Encodable` objects or values to `JavaScriptValue`. This implementation is incomplete,
- but it supports basic use cases with structs defined by the user and when the default `Encodable` implementation is used.
+ Encodes `Encodable` values to `JavaScriptValue`.
+
+ For any property whose static type is known to the dynamic-type registry
+ (anything routed via the `~` operator: arrays, dictionaries, optionals,
+ `RawRepresentable` enums, `Convertible`s, `JavaScriptValue` and so on),
+ the encoder takes the fast path through `castToJS`, preserving full
+ element-type metadata.
+
+ Only types the registry doesn't recognize (i.e. plain `Encodable` structs and
+ classes) fall back to Swift's `Encodable` machinery via `value.encode(to:)`.
  */
 internal final class JSValueEncoder: Encoder {
+  private let appContext: AppContext
   private let runtime: JavaScriptRuntime
-  private let valueHolder = JSValueHolder()
+  private let valueHolder: JSValueHolder
 
   /**
    The result of encoding to `JavaScriptValue`. Use this property after running `encode(to:)` on the encodable.
@@ -18,43 +27,106 @@ internal final class JSValueEncoder: Encoder {
   }
 
   /**
-   Initializes the encoder with the given runtime in which the value will be created.
+   Initializes the encoder with the given app context. Throws if the runtime has been lost.
+   */
+  convenience init(appContext: AppContext) throws {
+    try self.init(appContext: appContext, runtime: appContext.runtime)
+  }
+
+  /**
+   Initializes the encoder with the given app context and an explicit runtime.
+   Use this when produced JS values must live in a runtime other than the
+   one currently held by the app context.
    */
-  init(runtime: JavaScriptRuntime) {
+  convenience init(appContext: AppContext, runtime: JavaScriptRuntime) {
+    self.init(
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: [],
+      valueHolder: JSValueHolder()
+    )
+  }
+
+  fileprivate init(
+    appContext: AppContext,
+    runtime: JavaScriptRuntime,
+    codingPath: [any CodingKey],
+    valueHolder: JSValueHolder
+  ) {
+    self.appContext = appContext
     self.runtime = runtime
+    self.codingPath = codingPath
+    self.valueHolder = valueHolder
   }
 
   // MARK: - Encoder
 
-  // We don't use `codingPath` and `userInfo`, but they are required by the protocol.
-  let codingPath: [any CodingKey] = []
+  let codingPath: [any CodingKey]
   let userInfo: [CodingUserInfoKey: Any] = [:]
 
-  /**
-   Returns an encoding container appropriate for holding multiple values keyed by the given key type.
-   */
   func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {
-    let container = JSObjectEncodingContainer<Key>(to: valueHolder, runtime: runtime)
+    let container = JSObjectEncodingContainer<Key>(
+      to: valueHolder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
     return KeyedEncodingContainer(container)
   }
 
-  /**
-   Returns an encoding container appropriate for holding multiple unkeyed values.
-   */
   func unkeyedContainer() -> any UnkeyedEncodingContainer {
-    return JSArrayEncodingContainer(to: valueHolder, runtime: runtime)
+    return JSArrayEncodingContainer(
+      to: valueHolder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
   }
 
-  /**
-   Returns an encoding container appropriate for holding a single primitive value, including optionals.
-   */
   func singleValueContainer() -> any SingleValueEncodingContainer {
-    return JSValueEncodingContainer(to: valueHolder, runtime: runtime)
+    return JSValueEncodingContainer(
+      to: valueHolder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
   }
 }
 
+// MARK: - Shared encoding logic
+
 /**
- An object that holds a JS value that could be overriden by the encoding container.
+ Encodes a single value into a `JavaScriptValue`, routing through the dynamic-type
+ registry whenever possible and falling back to `Encodable` only for plain types.
+ */
+private func encodeUsingDynamicType<ValueType: Encodable>(
+  _ value: ValueType,
+  appContext: AppContext,
+  runtime: JavaScriptRuntime,
+  codingPath: [any CodingKey]
+) throws -> JavaScriptValue {
+  let dynamicType = ~ValueType.self
+
+  if !(dynamicType is DynamicEncodableType) {
+    return try dynamicType.castToJS(value, appContext: appContext, in: runtime)
+  }
+
+  // Plain Encodable type the registry doesn't recognize — recurse via Encodable.
+  let holder = JSValueHolder()
+  let encoder = JSValueEncoder(
+    appContext: appContext,
+    runtime: runtime,
+    codingPath: codingPath,
+    valueHolder: holder
+  )
+  try value.encode(to: encoder)
+  return holder.value
+}
+
+// MARK: - Containers
+
+/**
+ An object that holds a JS value, mutated by an encoding container as it makes progress.
  */
 private final class JSValueHolder {
   var value: JavaScriptValue = .undefined
@@ -64,146 +136,233 @@ private final class JSValueHolder {
  Single value container used to encode primitive values, including optionals.
  */
 private struct JSValueEncodingContainer: SingleValueEncodingContainer {
-  private weak var runtime: JavaScriptRuntime?
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
   private let valueHolder: JSValueHolder
+  let codingPath: [any CodingKey]
 
-  init(to valueHolder: JSValueHolder, runtime: JavaScriptRuntime?) {
-    self.runtime = runtime
+  init(to valueHolder: JSValueHolder, appContext: AppContext, runtime: JavaScriptRuntime, codingPath: [any CodingKey]) {
     self.valueHolder = valueHolder
+    self.appContext = appContext
+    self.runtime = runtime
+    self.codingPath = codingPath
   }
 
-  // MARK: - SingleValueEncodingContainer
-
-  // Unused, but required by the protocol.
-  let codingPath: [any CodingKey] = []
-
   mutating func encodeNil() throws {
-    self.valueHolder.value = .null
+    valueHolder.value = .null
   }
 
   mutating func encode<ValueType: Encodable>(_ value: ValueType) throws {
-    guard let runtime else {
-      // Do nothing when the runtime is already deallocated
-      return
-    }
-    let jsValue = JavaScriptValue.from(value, runtime: runtime)
-
-    // If the given value couldn't be converted to JavaScriptValue, try to encode it farther.
-    // It might be the case when the default implementation of `Encodable` has chosen the single value container
-    // for an optional type that should rather use keyed or unkeyed container when unwrapped.
-    if jsValue.isUndefined() {
-      let encoder = JSValueEncoder(runtime: runtime)
-      try value.encode(to: encoder)
-      self.valueHolder.value = encoder.value
-      return
-    }
-    self.valueHolder.value = jsValue
+    valueHolder.value = try encodeUsingDynamicType(
+      value,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
   }
 }
 
 /**
  Keyed container that encodes to a JavaScript object.
 
- - Note: This is a `class` (rather than `struct` like `JSArrayEncodingContainer` below)
-   because it holds a non-copyable `JavaScriptObject`. A struct property of a non-copyable
-   type makes the containing struct non-copyable too, which conflicts with
-   `KeyedEncodingContainerProtocol`'s expectation of a copyable conformer. Using a class
-   sidesteps the constraint via reference semantics.
+ - Note: This is a `class` (not a `struct`) because it holds a non-copyable
+   `JavaScriptObject`. A struct property of a non-copyable type makes the
+   containing struct non-copyable too, which conflicts with
+   `KeyedEncodingContainerProtocol`'s expectation of a copyable conformer.
+   Using a class sidesteps the constraint via reference semantics.
  */
-private class JSObjectEncodingContainer<Key: CodingKey>: KeyedEncodingContainerProtocol {
-  private weak var runtime: JavaScriptRuntime?
+private final class JSObjectEncodingContainer<Key: CodingKey>: KeyedEncodingContainerProtocol {
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
   private let valueHolder: JSValueHolder
-  private var object: JavaScriptObject
+  private let object: JavaScriptObject
+  let codingPath: [any CodingKey]
 
-  init(to valueHolder: JSValueHolder, runtime: JavaScriptRuntime) {
+  init(to valueHolder: JSValueHolder, appContext: AppContext, runtime: JavaScriptRuntime, codingPath: [any CodingKey]) {
     let object = runtime.createObject()
     valueHolder.value = object.asValue()
 
+    self.appContext = appContext
     self.runtime = runtime
-    self.object = object
     self.valueHolder = valueHolder
+    self.object = object
+    self.codingPath = codingPath
   }
 
-  // MARK: - KeyedEncodingContainerProtocol
-
-  // Unused, but required by the protocol.
-  var codingPath: [any CodingKey] = []
-
   func encodeNil(forKey key: Key) throws {
     object.setProperty(key.stringValue, value: JavaScriptValue.null)
   }
 
   func encode<ValueType: Encodable>(_ value: ValueType, forKey key: Key) throws {
-    guard let runtime else {
-      // Do nothing when the runtime is already deallocated
-      return
+    let encoded = try encodeUsingDynamicType(
+      value,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    object.setProperty(key.stringValue, value: encoded)
+  }
+
+  // The default `KeyedEncodingContainerProtocol.encodeIfPresent` does nothing for
+  // nil values, which leaves the JS object without the key entirely — so `'label' in obj`
+  // returns false and consumers can't distinguish "absent" from "explicitly null".
+  // Override every overload (one per primitive plus a generic `Encodable` one) so nil
+  // optional fields produce an explicit `null` instead.
+  func encodeIfPresent<ValueType: Encodable>(_ value: ValueType?, forKey key: Key) throws {
+    if let value {
+      try encode(value, forKey: key)
+    } else {
+      try encodeNil(forKey: key)
+    }
+  }
+
+  func encodeIfPresent(_ value: Bool?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: String?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Double?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Float?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int8?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int16?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int32?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int64?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt8?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt16?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt32?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt64?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+
+  private func encodeOptional<ValueType: Encodable>(_ value: ValueType?, forKey key: Key) throws {
+    if let value {
+      try encode(value, forKey: key)
+    } else {
+      try encodeNil(forKey: key)
     }
-    let encoder = JSValueEncoder(runtime: runtime)
-    try value.encode(to: encoder)
-    object.setProperty(key.stringValue, value: encoder.value)
   }
 
   func nestedContainer<NestedKey: CodingKey>(keyedBy keyType: NestedKey.Type, forKey key: Key) -> KeyedEncodingContainer<NestedKey> {
-    fatalError("JSValueEncoder does not support nested containers")
+    let holder = JSValueHolder()
+    let container = JSObjectEncodingContainer<NestedKey>(
+      to: holder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    object.setProperty(key.stringValue, value: holder.value)
+    return KeyedEncodingContainer(container)
   }
 
   func nestedUnkeyedContainer(forKey key: Key) -> any UnkeyedEncodingContainer {
-    fatalError("JSValueEncoder does not support nested containers")
+    let holder = JSValueHolder()
+    let container = JSArrayEncodingContainer(
+      to: holder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    object.setProperty(key.stringValue, value: holder.value)
+    return container
   }
 
   func superEncoder() -> any Encoder {
-    fatalError("superEncoder() is not implemented in JSValueEncoder")
+    fatalError("JSValueEncoder does not support superEncoder()")
   }
 
   func superEncoder(forKey key: Key) -> any Encoder {
-    return self.superEncoder()
+    fatalError("JSValueEncoder does not support superEncoder(forKey:)")
   }
 }
 
 /**
  Unkeyed container that encodes values to a JavaScript array.
+
+ Like `JSObjectEncodingContainer`, this is a `class` so it can hold the
+ non-copyable `JavaScriptArray` directly without forcing the container itself
+ to be non-copyable.
  */
-private struct JSArrayEncodingContainer: UnkeyedEncodingContainer {
-  private weak var runtime: JavaScriptRuntime?
+private final class JSArrayEncodingContainer: UnkeyedEncodingContainer {
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
   private let valueHolder: JSValueHolder
-  private var items: [JavaScriptValue] = []
+  private let array: JavaScriptArray
+  let codingPath: [any CodingKey]
+  var count: Int = 0
 
-  init(to valueHolder: JSValueHolder, runtime: JavaScriptRuntime) {
+  init(to valueHolder: JSValueHolder, appContext: AppContext, runtime: JavaScriptRuntime, codingPath: [any CodingKey]) {
+    let array = runtime.createArray()
+    valueHolder.value = array.asValue()
+
+    self.appContext = appContext
     self.runtime = runtime
     self.valueHolder = valueHolder
+    self.array = array
+    self.codingPath = codingPath
   }
 
-  // MARK: - UnkeyedEncodingContainer
-
-  // Unused, but required by the protocol.
-  var codingPath: [any CodingKey] = []
-  var count: Int = 0
+  func encodeNil() throws {
+    array[count] = JavaScriptValue.null
+    count += 1
+  }
 
-  mutating func encodeNil() throws {
-    items.append(JavaScriptValue.null)
+  func encode<ValueType: Encodable>(_ value: ValueType) throws {
+    let encoded = try encodeUsingDynamicType(
+      value,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [AnyCodingKey(intValue: count)]
+    )
+    array[count] = encoded
+    count += 1
   }
 
-  mutating func encode<ValueType: Encodable>(_ value: ValueType) throws {
-    guard let runtime else {
-      // Do nothing when the runtime is already deallocated
-      return
-    }
-    let encoder = JSValueEncoder(runtime: runtime)
-    try value.encode(to: encoder)
+  func nestedContainer<NestedKey: CodingKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> {
+    let holder = JSValueHolder()
+    let container = JSObjectEncodingContainer<NestedKey>(
+      to: holder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [AnyCodingKey(intValue: count)]
+    )
+    array[count] = holder.value
+    count += 1
+    return KeyedEncodingContainer(container)
+  }
 
-    items.append(encoder.value)
-    valueHolder.value = .representing(value: items, in: runtime)
+  func nestedUnkeyedContainer() -> any UnkeyedEncodingContainer {
+    let holder = JSValueHolder()
+    let container = JSArrayEncodingContainer(
+      to: holder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [AnyCodingKey(intValue: count)]
+    )
+    array[count] = holder.value
+    count += 1
+    return container
   }
 
-  mutating func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> where NestedKey : CodingKey {
-    fatalError("JSValueEncoder does not support nested containers")
+  func superEncoder() -> any Encoder {
+    fatalError("JSValueEncoder does not support superEncoder()")
   }
+}
+
+// MARK: - Helpers
+
+/**
+ A coding key carrying just a string and an integer index. Used to extend
+ `codingPath` with array indices in the unkeyed container, since unkeyed
+ containers have no associated `Key` type to draw from.
+ */
+private struct AnyCodingKey: CodingKey {
+  let stringValue: String
+  let intValue: Int?
 
-  mutating func nestedUnkeyedContainer() -> any UnkeyedEncodingContainer {
-    fatalError("JSValueEncoder does not support nested containers")
+  init(stringValue: String) {
+    self.stringValue = stringValue
+    self.intValue = Int(stringValue)
   }
 
-  mutating func superEncoder() -> any Encoder {
-    fatalError("superEncoder() is not implemented in JSValueEncoder")
+  init(intValue: Int) {
+    self.stringValue = String(intValue)
+    self.intValue = intValue
   }
 }

package/ios/JS/EXReactSchedulerDispatch.h

@@ -0,0 +1,28 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#ifdef __cplusplus
+
+namespace expo {
+
+/**
+ Trampoline that `ExpoModulesJSI` calls to dispatch work onto the JS thread.
+ Casts the `nativeScheduler` pointer back to a `react::RuntimeScheduler *` and
+ calls `scheduleTask` on it. The signature matches `expo::RuntimeScheduler::ScheduleFn`
+ declared in the xcframework's `RuntimeScheduler.h`.
+
+ Lives in ExpoModulesCore (rather than in the xcframework) so that
+ ExpoModulesJSI.framework's prebuilt binary doesn't need to link against
+ React-runtimescheduler — important for source-built RN, where those symbols
+ are hidden after link and unreachable via -undefined dynamic_lookup.
+
+ Hosts that initialize their own runtime (e.g. ExpoReactNativeFactory, Expo Go)
+ pass `&expo::dispatchOnReactScheduler` as the `dispatch` argument to
+ `AppContext.setRuntime`.
+ */
+void dispatchOnReactScheduler(void *nativeScheduler, int priority, void (^callback)()) noexcept;
+
+} // namespace expo
+
+#endif // __cplusplus

package/ios/JS/EXReactSchedulerDispatch.mm

@@ -0,0 +1,19 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+#import "EXReactSchedulerDispatch.h"
+
+#import <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
+namespace expo {
+
+void dispatchOnReactScheduler(void *nativeScheduler, int priority, void (^callback)()) noexcept
+{
+  auto *scheduler = static_cast<facebook::react::RuntimeScheduler *>(nativeScheduler);
+  scheduler->scheduleTask(
+    static_cast<facebook::react::SchedulerPriority>(priority),
+    [callback](facebook::jsi::Runtime &) {
+      callback();
+    });
+}
+
+} // namespace expo

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "56.0.5",
+  "version": "56.0.7",
   "description": "The core of Expo Modules architecture",
   "main": "src/index.ts",
   "types": "build/index.d.ts",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "@expo/expo-modules-macros-plugin": "~0.0.8",
-    "expo-modules-jsi": "~56.0.2",
+    "expo-modules-jsi": "~56.0.3",
     "invariant": "^2.2.4"
   },
   "peerDependencies": {
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.2"
   },
-  "gitHead": "a30353e69ca0d72b9fac5830abc631feda1ba3ae",
+  "gitHead": "40f0a6f6711d93762e0506b37e6e077e4bd9a541",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",