expo-modules-core 56.0.8 → 56.0.10

package/CHANGELOG.md

@@ -10,6 +10,22 @@
 
 ### 💡 Others
 
+## 56.0.10 — 2026-05-19
+
+### 🎉 New features
+
+- [iOS] `Decodable` types can now be used as native function arguments. JS values are decoded through the dynamic-type registry, so arrays, dictionaries, optionals, `RawRepresentable` enums and `Convertible`s are coerced consistently. ([#45705](https://github.com/expo/expo/pull/45705) by [@tsapeta](https://github.com/tsapeta))
+
+### 🐛 Bug fixes
+
+- [Android] Keep `ExpoComposeView` content visible during parent view transitions (e.g., `react-native-screens` pop navigation). ([#45942](https://github.com/expo/expo/pull/45942) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+
+## 56.0.9 — 2026-05-15
+
+### 🎉 New features
+
+- Added single-payload overloads for `SharedObject.emit` on iOS and Android. The iOS API also accepts an already-converted `JavaScriptValue` payload to skip the native-to-JS conversion step. ([#45596](https://github.com/expo/expo/pull/45596) by [@tsapeta](https://github.com/tsapeta))
+
 ## 56.0.8 — 2026-05-13
 
 ### 🐛 Bug fixes
@@ -28,6 +44,7 @@
 ### 💡 Others
 
 - [iOS] `AppContext.setRuntime` now takes the native React `RuntimeScheduler` pointer and a dispatch trampoline alongside the runtime pointer. ([#45636](https://github.com/expo/expo/pull/45636) by [@tsapeta](https://github.com/tsapeta))
+- Deprecated `SharedObject.emit(event:arguments:)` (iOS) and the `vararg` `emit` (Android) in favor of the new single-payload overloads. Existing single-argument call sites keep working unchanged. ([#45596](https://github.com/expo/expo/pull/45596) by [@tsapeta](https://github.com/tsapeta))
 
 ## 56.0.5 — 2026-05-08
 

package/android/build.gradle

@@ -27,7 +27,7 @@ if (shouldIncludeCompose) {
 }
 
 group = 'host.exp.exponent'
-version = '56.0.8'
+version = '56.0.10'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -94,7 +94,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "56.0.8"
+    versionName "56.0.10"
     buildConfigField "String", "EXPO_MODULES_CORE_VERSION", "\"${versionName}\""
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true"
 

package/android/src/compose/expo/modules/kotlin/views/ExpoComposeView.kt

@@ -13,6 +13,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.rememberUpdatedState
+import androidx.annotation.UiThread
 import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.platform.ViewCompositionStrategy
 import androidx.core.view.size
@@ -218,8 +219,42 @@ abstract class ExpoComposeView<T : ComposeProps>(
 
   override fun onViewRemoved(child: View?) {
     super.onViewRemoved(child)
+    // Keep compose views alive when view is transitioning
+    // e.g. pop transition from RN screens https://github.com/expo/expo/issues/45914
+    if (child != null && isViewTransitioning(child)) {
+      return
+    }
     recomposeScope?.invalidate()
   }
+
+  // Children currently animating out via startViewTransition. While a view is in this set,
+  // onViewRemoved skips invalidating the recompose scope so the child's compose subtree
+  // stays alive for the duration of the transition. Mirrors ViewGroup.mTransitioningViews.
+  private val transitioningChildren: MutableSet<View> = mutableSetOf()
+
+  override fun startViewTransition(view: View) {
+    super.startViewTransition(view)
+    if (view.parent == this) {
+      transitioningChildren.add(view)
+    }
+  }
+
+  override fun endViewTransition(view: View) {
+    super.endViewTransition(view)
+    if (transitioningChildren.remove(view) && view.parent != this) {
+      recomposeScope?.invalidate()
+    }
+  }
+
+  @UiThread
+  private fun isViewTransitioning(view: View): Boolean {
+    return transitioningChildren.contains(view)
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    transitioningChildren.clear()
+  }
 }
 
 /**

package/android/src/main/cpp/decorators/JSPropertiesDecorator.h

@@ -1,5 +1,7 @@
 // Copyright © 2021-present 650 Industries, Inc. (aka Expo)
 
+#pragma once
+
 #include "../ExpoHeader.pch"
 
 #include "../MethodMetadata.h"

package/android/src/main/cpp/fabric/AndroidExpoViewState.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "../ExpoHeader.pch"
 #include "ExpoViewState.h"
 

package/android/src/main/cpp/fabric/ExpoComponentDescriptorFactory.cpp

@@ -0,0 +1,31 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#include "ExpoComponentDescriptorFactory.h"
+#include "AndroidExpoViewComponentDescriptor.h"
+
+namespace react = facebook::react;
+
+namespace expo {
+
+StatePropMapType statePropMap = {};
+
+react::ComponentDescriptor::Unique concreteExpoComponentDescriptorConstructor(
+  const react::ComponentDescriptorParameters &parameters
+) {
+  auto descriptor = std::make_unique<AndroidExpoViewComponentDescriptor>(
+    parameters,
+    react::RawPropsParser(/*useRawPropsJsiValue=*/true)
+  );
+
+  if (statePropMap.contains(std::static_pointer_cast<std::string const>(parameters.flavor))) {
+    descriptor->setStateProps(
+      statePropMap.at(
+        std::static_pointer_cast<std::string const>(parameters.flavor)
+      )
+    );
+  }
+
+  return descriptor;
+}
+
+} // namespace expo

package/android/src/main/cpp/fabric/ExpoComponentDescriptorFactory.h

@@ -0,0 +1,23 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#include <react/renderer/core/ComponentDescriptor.h>
+#include "../types/FrontendConverter.h"
+
+namespace react = facebook::react;
+
+namespace expo {
+
+using StatePropMapType = std::unordered_map<
+  react::ComponentDescriptor::Flavor,
+  std::unordered_map<std::string, std::shared_ptr<FrontendConverter>>
+>;
+
+extern StatePropMapType statePropMap;
+
+react::ComponentDescriptor::Unique concreteExpoComponentDescriptorConstructor(
+  const react::ComponentDescriptorParameters &parameters
+);
+
+} // namespace expo

package/android/src/main/cpp/fabric/FabricComponentsRegistry.cpp

@@ -1,38 +1,16 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
 #include "FabricComponentsRegistry.h"
+#include "ExpoComponentDescriptorFactory.h"
 #include "../types/FrontendConverterProvider.h"
+#include <CoreComponentsRegistry.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProvider.h>
 
 namespace jni = facebook::jni;
 namespace react = facebook::react;
 
 namespace expo {
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wextern-initializer"
-// Clang think that we don't need to initialize the extern variable here, but we do.
-extern StatePropMapType statePropMap = {};
-#pragma clang diagnostic pop
-
-AndroidExpoViewComponentDescriptor::Unique concreteExpoComponentDescriptorConstructor(
-  const react::ComponentDescriptorParameters &parameters
-) {
-  auto descriptor = std::make_unique<AndroidExpoViewComponentDescriptor>(
-    parameters,
-    react::RawPropsParser(/*useRawPropsJsiValue=*/true)
-  );
-
-  if (statePropMap.contains(std::static_pointer_cast<std::string const>(parameters.flavor))) {
-    descriptor->setStateProps(
-      statePropMap.at(
-        std::static_pointer_cast<std::string const>(parameters.flavor)
-      )
-    );
-  }
-
-  return descriptor;
-}
-
 // static
 void FabricComponentsRegistry::registerNatives() {
   registerHybrid({

package/android/src/main/cpp/fabric/FabricComponentsRegistry.h

@@ -3,29 +3,12 @@
 #pragma once
 
 #include "../ExpoHeader.pch"
-#include <CoreComponentsRegistry.h>
-#include <react/renderer/componentregistry/ComponentDescriptorProvider.h>
-
 #include "../types/ExpectedType.h"
-#include "../types/FrontendConverter.h"
-#include "AndroidExpoViewComponentDescriptor.h"
 
 namespace jni = facebook::jni;
-namespace react = facebook::react;
 
 namespace expo {
 
-typedef std::unordered_map<
-  AndroidExpoViewComponentDescriptor::Flavor,
-  std::unordered_map<std::string, std::shared_ptr<FrontendConverter>>
-> StatePropMapType;
-
-extern StatePropMapType statePropMap;
-
-AndroidExpoViewComponentDescriptor::Unique concreteExpoComponentDescriptorConstructor(
-  const react::ComponentDescriptorParameters &parameters
-);
-
 class FabricComponentsRegistry : public jni::HybridClass<FabricComponentsRegistry> {
 public:
   static auto constexpr

package/android/src/main/java/expo/modules/kotlin/sharedobjects/SharedObject.kt

@@ -41,20 +41,42 @@ open class SharedObject(runtime: Runtime? = null) {
       )
   }
 
-  fun emit(eventName: String, vararg args: Any?) {
+  /**
+   * Emits an event with no payload to the associated JavaScript object.
+   */
+  fun emit(event: String) {
+    emitInternal(event, emptyArray())
+  }
+
+  /**
+   * Emits an event with a single payload to the associated JavaScript object.
+   */
+  fun emit(event: String, payload: Any?) {
+    emitInternal(event, arrayOf(payload))
+  }
+
+  @Deprecated(
+    "Multi-argument event emission is deprecated. Use `emit(event)` or `emit(event, payload)` and pass a single payload (typically a Map/Bundle) instead.",
+    ReplaceWith("emit(event, args)")
+  )
+  fun emit(event: String, vararg args: Any?) {
+    emitInternal(event, args)
+  }
+
+  private fun emitInternal(event: String, payload: Array<out Any?>) {
     val jsObject = getJavaScriptObject() ?: return
     val jniInterop = runtime?.jsiContext ?: return
     try {
       JNIUtils.emitEvent(
         jsObject,
         jniInterop,
-        eventName,
-        args
+        event,
+        payload
           .map { JSTypeConverterProvider.convertToJSValue(it, useExperimentalConverter = true) }
           .toTypedArray()
       )
     } catch (e: Throwable) {
-      logger.error("Unable to send event '$eventName' by shared object of type ${this::class.java.simpleName}", e)
+      logger.error("Unable to send event '$event' by shared object of type ${this::class.java.simpleName}", e)
     }
   }
 

package/expo-module-gradle-plugin/src/main/kotlin/expo/modules/plugin/android/MavenPublicationExtension.kt

@@ -208,7 +208,7 @@ private fun Project.expoPublishBody(publicationInfo: PublicationInfo, expoModule
   providers.exec { env ->
     env.workingDir(layout.projectDirectory.file(".."))
     // TODO(@lukmccall): support other package managers
-    env.commandLine("yarn", "prettier", "--write", "expo-module.config.json")
+    env.commandLine("pnpm", "prettier", "--write", "expo-module.config.json")
   }.result.get()
 }
 

package/ios/Core/AnyCodingKey.swift

@@ -0,0 +1,21 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+/**
+ A coding key carrying just a string and an integer index. Used to extend
+ `codingPath` with array indices in unkeyed containers, since unkeyed
+ containers have no associated `Key` type to draw from.
+ */
+internal struct AnyCodingKey: CodingKey {
+  let stringValue: String
+  let intValue: Int?
+
+  init(stringValue: String) {
+    self.stringValue = stringValue
+    self.intValue = Int(stringValue)
+  }
+
+  init(intValue: Int) {
+    self.stringValue = String(intValue)
+    self.intValue = intValue
+  }
+}

package/ios/Core/DynamicTypes/{DynamicEncodableType.swift → DynamicCodableType.swift}

@@ -3,29 +3,33 @@
 import ExpoModulesJSI
 
 /**
- Dynamic type for values conforming to `Encodable` protocol.
- Note that currently it can only encode from native to JavaScript values, thus cannot be used for arguments.
+ Dynamic type for values that conform to `Encodable` and/or `Decodable`. Native→JS
+ goes through `JSValueEncoder` (requires `Encodable`); JS→native goes through
+ `JSValueDecoder` (requires `Decodable`). Either direction throws if the wrapped
+ type doesn't conform to the protocol it needs.
  */
-internal struct DynamicEncodableType: AnyDynamicType {
-  static let shared = DynamicEncodableType()
-
-  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
-    return type is Encodable
+internal struct DynamicCodableType<InnerType>: AnyDynamicType {
+  func wraps<AnyInnerType>(_ type: AnyInnerType.Type) -> Bool {
+    return type == InnerType.self
   }
 
   func equals(_ type: any AnyDynamicType) -> Bool {
-    // Just mocking it here as we don't really need this function and we rather want to keep it a singleton
-    return false
+    return type is Self
   }
 
   func cast(jsValue: JavaScriptValue, appContext: AppContext) throws -> Any {
-    // TODO: Create DynamicDecodableType and reuse it here – that would work perfectly with Codable types
-    fatalError("DynamicEncodableType can only cast to JavaScript, not from")
+    guard let DecodableType = InnerType.self as? Decodable.Type else {
+      throw Conversions.CastingJSValueException<InnerType>(jsValue.kind)
+    }
+    let decoder = try JSValueDecoder(value: jsValue, appContext: appContext)
+    return try DecodableType.init(from: decoder)
   }
 
   func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
-    // TODO: Create DynamicDecodableType and reuse it here – that would work perfectly with Codable types
-    fatalError("DynamicEncodableType can only cast to JavaScript, not from")
+    if let value = value as? InnerType {
+      return value
+    }
+    throw Conversions.CastingException<InnerType>(value)
   }
 
   func castToJS<ValueType>(_ value: ValueType, appContext: AppContext) throws -> JavaScriptValue {
@@ -50,6 +54,6 @@ internal struct DynamicEncodableType: AnyDynamicType {
   }
 
   var description: String {
-    "Encodable"
+    "Codable<\(InnerType.self)>"
   }
 }

package/ios/Core/DynamicTypes/DynamicType.swift

@@ -19,10 +19,10 @@ private func DynamicType<T>(_ type: T.Type) -> AnyDynamicType {
   if T.self == Void.self {
     return DynamicVoidType.shared
   }
-  if T.self is Encodable.Type {
-    // There is no dedicated `~` operator overload for encodables to avoid ambiguity
-    // when the type is both `AnyArgument` and `Encodable` (e.g. strings, numeric types).
-    return DynamicEncodableType.shared
+  if T.self is Encodable.Type || T.self is Decodable.Type {
+    // There is no dedicated `~` operator overload for Codable types to avoid ambiguity
+    // when the type is both `AnyArgument` and `Encodable`/`Decodable` (e.g. strings, numeric types).
+    return DynamicCodableType<T>()
   }
   return DynamicRawType(innerType: T.self)
 }

package/ios/Core/ExpoModulesMacros.swift

@@ -1,8 +1,6 @@
-
-/**
- Declares macro signatures whose implementations are provided by the `@expo/expo-modules-macros-plugin` binary.
- Keep in sync with `@expo/expo-modules-macros-plugin/apple/Sources/ExpoModulesOptimized/ExpoModulesOptimized.swift`.
- */
+// Declares macro signatures whose implementations are provided by the `ExpoModulesMacros` compiler
+// plugin shipped in the `@expo/expo-modules-macros-plugin` package. Keep the `#externalMacro`
+// module/type names below in sync with the macro implementations in that package.
 
 // MARK: - Macro declarations
 
@@ -25,3 +23,64 @@
 @attached(peer, names: arbitrary)
 public macro OptimizedFunction() =
   #externalMacro(module: "ExpoModulesMacros", type: "OptimizedFunctionAttachedMacro")
+
+/// Marker macro applied to module / shared-object members that should be exposed to JavaScript.
+/// The accompanying `@ExpoModule` and `@SharedObject` macros discover `@JS`-marked declarations
+/// and generate the matching `Function` / `AsyncFunction` / `Property` / `Constructor` registrations.
+///
+/// Usage:
+///
+///     @JS
+///     func greet(name: String) -> String { ... }
+///
+///     @JS("doWork")
+///     func performWork() async throws { ... }
+///
+///     @JS
+///     var status: String { "ok" }
+@attached(peer)
+public macro JS(_ jsName: String? = nil) =
+  #externalMacro(module: "ExpoModulesMacros", type: "JSMacro")
+
+/// Member macro applied to a `Module` subclass. Scans the class body for declarations
+/// marked with `@JS` and synthesizes a framework-internal `_exposedDefinition()` method.
+/// `expo-modules-core` calls it automatically and merges the result into the module's
+/// definition, so the user doesn't have to reference it from `definition()`.
+///
+/// Usage:
+///
+///     @ExpoModule
+///     public final class MyModule: Module {
+///       public func definition() -> ModuleDefinition {
+///         Name("MyModule")
+///       }
+///
+///       @JS
+///       func greet(name: String) -> String { "Hi, \(name)" }
+///     }
+@attached(member, names: named(_exposedDefinition), named(appContext), named(init))
+public macro ExpoModule(_ name: String? = nil, classes: [Any.Type] = []) =
+  #externalMacro(module: "ExpoModulesMacros", type: "ExpoModuleMacro")
+
+/// Member macro applied to a `SharedObject` subclass. Scans the class body for declarations
+/// marked with `@JS` (including a single `@JS init(...)` for the JS constructor) and
+/// synthesizes a `_exposedClassDefinition()` static method returning a `ClassDefinition`.
+/// The companion `@ExpoModule(classes: [Foo.self])` wires the class into the module's
+/// exposed surface.
+///
+/// Usage:
+///
+///     @SharedObject
+///     final class Cache: SharedObject {
+///       @JS
+///       init(name: String) { self.name = name }
+///
+///       @JS
+///       func get(_ key: String) -> String? { ... }
+///
+///       @JS
+///       var size: Int { 42 }
+///     }
+@attached(member, names: named(_exposedClassDefinition))
+public macro SharedObject(_ name: String? = nil) =
+  #externalMacro(module: "ExpoModulesMacros", type: "SharedObjectMacro")

package/ios/Core/JSValueDecoder.swift

@@ -0,0 +1,452 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+
+/**
+ Decodes `JavaScriptValue`s into `Decodable` Swift values.
+
+ 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 decoder takes the fast path through `cast(jsValue:)`, preserving full
+ element-type metadata and picking up `Convertible` coercions for free.
+
+ Only types the registry doesn't recognize (i.e. plain `Decodable` structs and
+ classes) fall back to Swift's `Decodable` machinery via `T.init(from: decoder)`.
+ */
+internal final class JSValueDecoder: Decoder {
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
+  private let value: JavaScriptValue
+
+  /**
+   Initializes the decoder with the given JS value and app context.
+   Throws if the runtime has been lost.
+   */
+  convenience init(value: JavaScriptValue, appContext: AppContext) throws {
+    try self.init(value: value, appContext: appContext, runtime: appContext.runtime)
+  }
+
+  /**
+   Initializes the decoder with the given JS value, app context and an explicit runtime.
+   Use this when the source JS value lives in a runtime other than the one currently
+   held by the app context.
+   */
+  convenience init(value: JavaScriptValue, appContext: AppContext, runtime: JavaScriptRuntime) {
+    self.init(value: value, appContext: appContext, runtime: runtime, codingPath: [])
+  }
+
+  fileprivate init(
+    value: JavaScriptValue,
+    appContext: AppContext,
+    runtime: JavaScriptRuntime,
+    codingPath: [any CodingKey]
+  ) {
+    self.value = value
+    self.appContext = appContext
+    self.runtime = runtime
+    self.codingPath = codingPath
+  }
+
+  // MARK: - Decoder
+
+  let codingPath: [any CodingKey]
+  let userInfo: [CodingUserInfoKey: Any] = [:]
+
+  func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key> where Key: CodingKey {
+    guard value.isObject() else {
+      throw DecodingError.typeMismatch(
+        [String: Any].self,
+        DecodingError.Context(
+          codingPath: codingPath,
+          debugDescription: "Expected a JavaScript object to decode keyed container, got \(value.kind.rawValue)"
+        )
+      )
+    }
+    let container = JSObjectDecodingContainer<Key>(
+      object: value.getObject(),
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
+    return KeyedDecodingContainer(container)
+  }
+
+  func unkeyedContainer() throws -> any UnkeyedDecodingContainer {
+    guard value.isArray() else {
+      throw DecodingError.typeMismatch(
+        [Any].self,
+        DecodingError.Context(
+          codingPath: codingPath,
+          debugDescription: "Expected a JavaScript array to decode unkeyed container, got \(value.kind.rawValue)"
+        )
+      )
+    }
+    return JSArrayDecodingContainer(
+      array: value.getArray(),
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
+  }
+
+  func singleValueContainer() throws -> any SingleValueDecodingContainer {
+    return JSValueDecodingContainer(
+      value: value,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
+  }
+}
+
+// MARK: - Shared decoding logic
+
+/**
+ Decodes a single JS value into a typed Swift value, routing through the
+ dynamic-type registry whenever possible and falling back to `Decodable` only
+ for plain types.
+ */
+private func decodeUsingDynamicType<ValueType: Decodable>(
+  _ type: ValueType.Type,
+  from jsValue: JavaScriptValue,
+  appContext: AppContext,
+  runtime: JavaScriptRuntime,
+  codingPath: [any CodingKey]
+) throws -> ValueType {
+  let dynamicType = ~ValueType.self
+
+  if !(dynamicType is DynamicCodableType<ValueType>) {
+    do {
+      let anyValue = try JavaScriptActor.assumeIsolated {
+        return try dynamicType.cast(jsValue: jsValue, appContext: appContext)
+      }
+      guard let typed = anyValue as? ValueType else {
+        throw DecodingError.typeMismatch(
+          ValueType.self,
+          DecodingError.Context(
+            codingPath: codingPath,
+            debugDescription: "Dynamic type \(dynamicType) produced \(Swift.type(of: anyValue)) which is not \(ValueType.self)"
+          )
+        )
+      }
+      return typed
+    } catch let error as DecodingError {
+      throw error
+    } catch {
+      throw DecodingError.dataCorrupted(
+        DecodingError.Context(
+          codingPath: codingPath,
+          debugDescription: "Failed to cast JS value to \(ValueType.self)",
+          underlyingError: error
+        )
+      )
+    }
+  }
+
+  // Plain Decodable type the registry doesn't recognize — recurse via Decodable.
+  let decoder = JSValueDecoder(value: jsValue, appContext: appContext, runtime: runtime, codingPath: codingPath)
+  return try ValueType(from: decoder)
+}
+
+// MARK: - Containers
+
+/**
+ Single value container that reads a JS primitive (or unwraps an Optional).
+ */
+private struct JSValueDecodingContainer: SingleValueDecodingContainer {
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
+  private let value: JavaScriptValue
+  let codingPath: [any CodingKey]
+
+  init(value: JavaScriptValue, appContext: AppContext, runtime: JavaScriptRuntime, codingPath: [any CodingKey]) {
+    self.value = value
+    self.appContext = appContext
+    self.runtime = runtime
+    self.codingPath = codingPath
+  }
+
+  func decodeNil() -> Bool {
+    return value.isNull() || value.isUndefined()
+  }
+
+  func decode<ValueType: Decodable>(_ type: ValueType.Type) throws -> ValueType {
+    return try decodeUsingDynamicType(
+      type,
+      from: value,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
+  }
+}
+
+/**
+ Keyed container that reads from a JS object.
+
+ - Note: This is a `class` (not a `struct`) for the same reason as the encoder's
+   keyed container: it holds a non-copyable `JavaScriptObject`. See
+   `JSObjectEncodingContainer` for the full rationale.
+ */
+private final class JSObjectDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol {
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
+  private let object: JavaScriptObject
+  let codingPath: [any CodingKey]
+
+  init(object: consuming JavaScriptObject, appContext: AppContext, runtime: JavaScriptRuntime, codingPath: [any CodingKey]) {
+    self.object = object
+    self.appContext = appContext
+    self.runtime = runtime
+    self.codingPath = codingPath
+  }
+
+  lazy var allKeys: [Key] = object.getPropertyNames().compactMap { Key(stringValue: $0) }
+
+  func contains(_ key: Key) -> Bool {
+    return object.hasProperty(key.stringValue)
+  }
+
+  func decodeNil(forKey key: Key) throws -> Bool {
+    let value = object.getProperty(key.stringValue)
+    return value.isNull() || value.isUndefined()
+  }
+
+  // JS doesn't meaningfully distinguish "key absent" from "value undefined" at the
+  // consumer level — a single `getProperty` fetch returns `undefined` in both cases.
+  // Collapse both into `keyNotFound` so the caller gets the more useful error.
+  func decode<ValueType: Decodable>(_ type: ValueType.Type, forKey key: Key) throws -> ValueType {
+    let jsValue = object.getProperty(key.stringValue)
+    if jsValue.isUndefined() {
+      throw DecodingError.keyNotFound(
+        key,
+        DecodingError.Context(
+          codingPath: codingPath,
+          debugDescription: "No value found for key \(key.stringValue)"
+        )
+      )
+    }
+    return try decodeUsingDynamicType(
+      type,
+      from: jsValue,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+  }
+
+  // Swift's default `decodeIfPresent` calls `contains(key)` and then `decodeNil(forKey:)`;
+  // for present-but-null JS keys this works, but it doesn't reach our dynamic-type
+  // fast path. Override to make optional decoding consistently route through it.
+  // `JavaScriptObject.getProperty` returns `undefined` for missing keys, so a single
+  // fetch covers both "absent" and "explicit null/undefined" cases.
+  func decodeIfPresent<ValueType: Decodable>(_ type: ValueType.Type, forKey key: Key) throws -> ValueType? {
+    let jsValue = object.getProperty(key.stringValue)
+    if jsValue.isNull() || jsValue.isUndefined() {
+      return nil
+    }
+    return try decodeUsingDynamicType(
+      type,
+      from: jsValue,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+  }
+
+  func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type, forKey key: Key) throws -> KeyedDecodingContainer<NestedKey> where NestedKey: CodingKey {
+    let jsValue = object.getProperty(key.stringValue)
+    guard jsValue.isObject() else {
+      throw DecodingError.typeMismatch(
+        [String: Any].self,
+        DecodingError.Context(
+          codingPath: codingPath + [key],
+          debugDescription: "Expected a JavaScript object for nested keyed container, got \(jsValue.kind.rawValue)"
+        )
+      )
+    }
+    let container = JSObjectDecodingContainer<NestedKey>(
+      object: jsValue.getObject(),
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    return KeyedDecodingContainer(container)
+  }
+
+  func nestedUnkeyedContainer(forKey key: Key) throws -> any UnkeyedDecodingContainer {
+    let jsValue = object.getProperty(key.stringValue)
+    guard jsValue.isArray() else {
+      throw DecodingError.typeMismatch(
+        [Any].self,
+        DecodingError.Context(
+          codingPath: codingPath + [key],
+          debugDescription: "Expected a JavaScript array for nested unkeyed container, got \(jsValue.kind.rawValue)"
+        )
+      )
+    }
+    return JSArrayDecodingContainer(
+      array: jsValue.getArray(),
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+  }
+
+  func superDecoder() throws -> any Decoder {
+    throw DecodingError.dataCorrupted(
+      DecodingError.Context(
+        codingPath: codingPath,
+        debugDescription: "JSValueDecoder does not support superDecoder()"
+      )
+    )
+  }
+
+  func superDecoder(forKey key: Key) throws -> any Decoder {
+    throw DecodingError.dataCorrupted(
+      DecodingError.Context(
+        codingPath: codingPath + [key],
+        debugDescription: "JSValueDecoder does not support superDecoder(forKey:)"
+      )
+    )
+  }
+}
+
+/**
+ Unkeyed container that reads from a JS array.
+
+ Like `JSObjectDecodingContainer`, this is a `class` so it can hold the
+ non-copyable `JavaScriptArray` directly.
+ */
+private final class JSArrayDecodingContainer: UnkeyedDecodingContainer {
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
+  private let array: JavaScriptArray
+  let codingPath: [any CodingKey]
+  var currentIndex: Int = 0
+
+  init(array: consuming JavaScriptArray, appContext: AppContext, runtime: JavaScriptRuntime, codingPath: [any CodingKey]) {
+    self.array = array
+    self.appContext = appContext
+    self.runtime = runtime
+    self.codingPath = codingPath
+  }
+
+  var count: Int? { array.length }
+  var isAtEnd: Bool { currentIndex >= array.length }
+
+  func decodeNil() throws -> Bool {
+    let jsValue = try nextValue(Any?.self)
+    if jsValue.isNull() || jsValue.isUndefined() {
+      currentIndex += 1
+      return true
+    }
+    return false
+  }
+
+  func decode<ValueType: Decodable>(_ type: ValueType.Type) throws -> ValueType {
+    let jsValue = try nextValue(type)
+    let key = AnyCodingKey(intValue: currentIndex)
+    let decoded = try decodeUsingDynamicType(
+      type,
+      from: jsValue,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    currentIndex += 1
+    return decoded
+  }
+
+  func decodeIfPresent<ValueType: Decodable>(_ type: ValueType.Type) throws -> ValueType? {
+    if isAtEnd {
+      return nil
+    }
+    let jsValue = try array.getValue(at: currentIndex)
+    if jsValue.isNull() || jsValue.isUndefined() {
+      currentIndex += 1
+      return nil
+    }
+    let key = AnyCodingKey(intValue: currentIndex)
+    let decoded = try decodeUsingDynamicType(
+      type,
+      from: jsValue,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    currentIndex += 1
+    return decoded
+  }
+
+  func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type) throws -> KeyedDecodingContainer<NestedKey> where NestedKey: CodingKey {
+    let jsValue = try nextValue(KeyedDecodingContainer<NestedKey>.self)
+    let key = AnyCodingKey(intValue: currentIndex)
+    guard jsValue.isObject() else {
+      throw DecodingError.typeMismatch(
+        [String: Any].self,
+        DecodingError.Context(
+          codingPath: codingPath + [key],
+          debugDescription: "Expected a JavaScript object for nested keyed container, got \(jsValue.kind.rawValue)"
+        )
+      )
+    }
+    let container = JSObjectDecodingContainer<NestedKey>(
+      object: jsValue.getObject(),
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    currentIndex += 1
+    return KeyedDecodingContainer(container)
+  }
+
+  func nestedUnkeyedContainer() throws -> any UnkeyedDecodingContainer {
+    let jsValue = try nextValue((any UnkeyedDecodingContainer).self)
+    let key = AnyCodingKey(intValue: currentIndex)
+    guard jsValue.isArray() else {
+      throw DecodingError.typeMismatch(
+        [Any].self,
+        DecodingError.Context(
+          codingPath: codingPath + [key],
+          debugDescription: "Expected a JavaScript array for nested unkeyed container, got \(jsValue.kind.rawValue)"
+        )
+      )
+    }
+    let container = JSArrayDecodingContainer(
+      array: jsValue.getArray(),
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    currentIndex += 1
+    return container
+  }
+
+  // Reads the element at `currentIndex`, throwing `valueNotFound` (rather than letting
+  // `JavaScriptArray.getValue(at:)` throw its non-`DecodingError` out-of-range error)
+  // when the unkeyed container has been exhausted.
+  private func nextValue<RequestedType>(_ expected: RequestedType.Type) throws -> JavaScriptValue {
+    if isAtEnd {
+      throw DecodingError.valueNotFound(
+        expected,
+        DecodingError.Context(
+          codingPath: codingPath + [AnyCodingKey(intValue: currentIndex)],
+          debugDescription: "Unkeyed container is at end — no value available at index \(currentIndex)"
+        )
+      )
+    }
+    return try array.getValue(at: currentIndex)
+  }
+
+  func superDecoder() throws -> any Decoder {
+    throw DecodingError.dataCorrupted(
+      DecodingError.Context(
+        codingPath: codingPath,
+        debugDescription: "JSValueDecoder does not support superDecoder()"
+      )
+    )
+  }
+}
+

package/ios/Core/JSValueEncoder.swift

@@ -107,7 +107,7 @@ private func encodeUsingDynamicType<ValueType: Encodable>(
 ) throws -> JavaScriptValue {
   let dynamicType = ~ValueType.self
 
-  if !(dynamicType is DynamicEncodableType) {
+  if !(dynamicType is DynamicCodableType<ValueType>) {
     return try dynamicType.castToJS(value, appContext: appContext, in: runtime)
   }
 
@@ -345,24 +345,3 @@ private final class JSArrayEncodingContainer: UnkeyedEncodingContainer {
   }
 }
 
-// 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?
-
-  init(stringValue: String) {
-    self.stringValue = stringValue
-    self.intValue = Int(stringValue)
-  }
-
-  init(intValue: Int) {
-    self.stringValue = String(intValue)
-    self.intValue = intValue
-  }
-}

package/ios/Core/ModuleHolder.swift

@@ -46,10 +46,28 @@ public final class ModuleHolder {
     self.appContext = appContext
     self._name = name
     self.module = module
-    self.definition = module.definition()
+    self.definition = ModuleHolder.buildDefinition(for: module)
     post(event: .moduleCreate)
   }
 
+  /// Combines the user-authored definition with the entries synthesized by the
+  /// `@ExpoModule` macro on this module's class (if any). The macro emits a
+  /// `_exposedDefinition()` method returning an `[AnyDefinition]` array of the
+  /// `Function` / `Property` / `Constructor` entries it generated from `@JS`
+  /// members. Those entries are prepended to the user's definitions and the
+  /// whole list is fed back through `ModuleDefinition.init` so the merged
+  /// result is rebucketed (into `functions`, `properties`, etc.) just like a
+  /// hand-written definition. Modules that don't use the macro fall through
+  /// the empty-exposed fast path and return the user's definition unchanged.
+  private static func buildDefinition(for module: AnyModule) -> ModuleDefinition {
+    let userDefinition = module.definition()
+    let exposed = module._exposedDefinition()
+    if exposed.isEmpty {
+      return userDefinition
+    }
+    return ModuleDefinition(definitions: exposed + userDefinition.rawDefinitions)
+  }
+
   // MARK: Constants
 
   /**

package/ios/Core/Modules/ModuleDefinition.swift

@@ -29,10 +29,17 @@ public final class ModuleDefinition: ObjectDefinition {
 
   let eventObservers: [AnyEventObservingDefinition]
 
+  /// The raw list of definitions used to construct this module. Retained so
+  /// that `ModuleHolder` can merge in the entries synthesized by the
+  /// `@ExpoModule` macro without losing the user-authored ones.
+  let rawDefinitions: [AnyDefinition]
+
   /**
    Initializer that is called by the `ModuleDefinitionBuilder` results builder.
    */
   override init(definitions: [AnyDefinition]) {
+    self.rawDefinitions = definitions
+
     self.name = definitions
       .compactMap { $0 as? ModuleNameDefinition }
       .last?

package/ios/Core/Protocols/AnyModule.swift

@@ -14,4 +14,16 @@ public protocol AnyModule: AnyObject, AnyArgument {
    */
   @ModuleDefinitionBuilder
   func definition() -> ModuleDefinition
+
+  /// Returns definitions synthesized from `@JS`-annotated members by the `@ExpoModule` macro.
+  /// Framework-internal: the leading underscore signals this is not part of the public API and
+  /// should only be called by `expo-modules-core` itself. Modules that don't use the macro fall
+  /// back to the default empty implementation.
+  func _exposedDefinition() -> [AnyDefinition]
+}
+
+public extension AnyModule {
+  func _exposedDefinition() -> [AnyDefinition] {
+    return []
+  }
 }

package/ios/Core/SharedObjects/SharedObject.swift

@@ -66,66 +66,87 @@ open class SharedObject: AnySharedObject {
   public func getJavaScriptObject() -> JavaScriptObject? {
     return appContext?.sharedObjectRegistry.toJavaScriptObject(self)
   }
-}
 
-// Unfortunately the `emit` function needs to be defined in the extension.
-// When put in the class, pack expansion is crashing with `EXC_BAD_ACCESS` code.
-// See https://github.com/apple/swift/issues/72381 for more details.
-public extension SharedObject { // swiftlint:disable:this no_grouping_extension
-  // Parameter packs feature requires Swift 5.9 (Xcode 15.0), but some CIs and EAS images may still use older versions.
-  // As of April 29, all submissions must be made with Xcode 15, so hopefully we can remove this condition soon.
-  // No one should use <15.0 these days.
-  #if swift(>=5.9)
   /**
-   Schedules an event with the given name and arguments to be emitted to the associated JavaScript object.
+   Schedules an event with the given name and a pre-converted JavaScript payload to be emitted
+   to the associated JavaScript object. This is the lowest-level emit overload — use it when the
+   value is already a `JavaScriptValue` to skip the native-to-JS conversion step.
    */
-  func emit<each A: AnyArgument>(event: String, arguments: repeat each A) {
+  public func emit(event: String, payload: JavaScriptValue) {
     guard let appContext, let runtime = try? appContext.runtime else {
       log.warn("Trying to send event '\(event)' to \(type(of: self)), but the JS runtime has been lost")
       return
     }
+    guard let jsValue = getJavaScriptValue() else {
+      log.warn("Trying to send event '\(event)' to JS, but the JS object is no longer associated with the native instance")
+      return
+    }
+    runtime.schedule {
+      dispatch(event: event, payload: payload, to: jsValue, in: runtime)
+    }
+  }
 
-    // Collect arguments and their dynamic types from parameter pack
-    var argumentPairs: [(AnyArgument, AnyDynamicType)] = []
-    repeat argumentPairs.append((each arguments, ~(each A).self))
+  /**
+   Schedules an event with the given name to be emitted to the associated JavaScript object.
+   */
+  public func emit(event: String) {
+    emit(event: event, payload: .undefined)
+  }
 
-    // Schedule the event to be asynchronously emitted from the runtime's thread
-    runtime.schedule { [weak self, weak appContext] in
-      guard let appContext, let runtime = try? appContext.runtime, let jsValue = self?.getJavaScriptValue() else {
-        log.warn("Trying to send event '\(event)' to \(type(of: self)), but the JS object is no longer associated with the native instance")
+  /**
+   Schedules an event with the given name and payload to be emitted to the associated JavaScript object.
+   */
+  public func emit<P: AnyArgument>(event: String, payload: sending P) {
+    guard let appContext, let runtime = try? appContext.runtime else {
+      log.warn("Trying to send event '\(event)' to \(type(of: self)), but the JS runtime has been lost")
+      return
+    }
+    guard let jsValue = getJavaScriptValue() else {
+      log.warn("Trying to send event '\(event)' to JS, but the JS object is no longer associated with the native instance")
+      return
+    }
+    runtime.schedule { [weak appContext] in
+      guard let appContext else {
         return
       }
-
-      // Convert native arguments to JS, just like function results
-      let jsArguments: [JavaScriptValue]
       do {
-        jsArguments = try argumentPairs.map { argument, dynamicType in
-          try dynamicType.convertToJS(argument, appContext: appContext)
-        }
+        let jsPayload = try (~P.self).castToJS(payload, appContext: appContext, in: runtime)
+        dispatch(event: event, payload: jsPayload, to: jsValue, in: runtime)
       } catch {
-        log.warn("Failed to convert arguments for event '\(event)' on \(type(of: self)); the event will not be emitted: \(error)")
+        log.warn("Failed to convert payload for event '\(event)' on \(P.self); the event will not be emitted: \(error)")
         return
       }
+    }
+  }
 
-      let argumentsBuffer = JavaScriptValuesBuffer.copying(in: runtime, values: jsArguments)
-
-      runtime.withUnsafePointee { runtimePtr in
-        jsValue.withUnsafePointee { objectPtr in
-          JSUtils.emitEvent(
-            event,
-            runtimePointer: runtimePtr,
-            objectPointer: objectPtr,
-            argumentsPointer: argumentsBuffer.rawBaseAddress,
-            argumentCount: UInt(argumentsBuffer.count)
-          )
-        }
+  /**
+   Backwards-compatible overload that forwards to `emit(event:payload:)`. Existing single-argument
+   call sites keep working unchanged; the parameter has been renamed to `payload` to make the
+   single-payload semantics explicit, so callers should migrate the label.
+   */
+  @available(*, deprecated, renamed: "emit(event:payload:)", message: "Use `emit(event:payload:)` and pass a single value (typically a dictionary). Multi-argument event emission is no longer supported.")
+  public func emit<P: AnyArgument>(event: String, arguments: sending P) {
+    emit(event: event, payload: arguments)
+  }
+}
+
+/**
+ Sends a pre-converted event payload to the given JavaScript object via the JSI emitter helper.
+ Must run on the JS thread; the public `emit` overloads schedule onto the runtime before calling in.
+ */
+@JavaScriptActor
+private func dispatch(event: String, payload: JavaScriptValue, to value: JavaScriptValue, in runtime: JavaScriptRuntime) {
+  runtime.withUnsafePointee { runtimePtr in
+    value.withUnsafePointee { objectPtr in
+      payload.withUnsafePointee { payloadPtr in
+        JSUtils.emitEvent(
+          event,
+          runtimePointer: runtimePtr,
+          objectPointer: objectPtr,
+          argumentsPointer: payloadPtr,
+          argumentCount: 1
+        )
       }
     }
   }
-  #else // swift(>=5.9)
-  @available(*, unavailable, message: "Unavailable in Xcode <15.0")
-  public func emit(event: String, arguments: AnyArgument...) {
-    fatalError("Emitting events to JS requires at least Xcode 15.0")
-  }
-  #endif // swift(<5.9)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "56.0.8",
+  "version": "56.0.10",
   "description": "The core of Expo Modules architecture",
   "main": "src/index.ts",
   "types": "build/index.d.ts",
@@ -46,8 +46,8 @@
     "preset": "expo-module-scripts"
   },
   "dependencies": {
-    "@expo/expo-modules-macros-plugin": "~0.0.8",
-    "expo-modules-jsi": "~56.0.4",
+    "@expo/expo-modules-macros-plugin": "~0.0.9",
+    "expo-modules-jsi": "~56.0.6",
     "invariant": "^2.2.4"
   },
   "peerDependencies": {
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.2"
   },
-  "gitHead": "51c27fce31a5b3a877a4b05d832dabf4a99db5e1",
+  "gitHead": "290368bc41026449a05a4ebf991b85c3a2fb0e3a",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",