expo-modules-core 57.0.13 → 57.0.15

package/CHANGELOG.md

@@ -10,6 +10,29 @@
 
 ### 💡 Others
 
+## 57.0.15 — 2026-09-01
+
+### 🐛 Bug fixes
+
+- [iOS][Android] Fixed a `matchContents` `RNHostView` and the `matchContents` host around it feeding each other's size back and forth, which grew the layout on every pass. ([#49483](https://github.com/expo/expo/pull/49483) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+- [iOS] Fixed SwiftUI view props re-decoding every field on every props update. Fabric sends the whole props map rather than a delta, so an unrelated prop change replaced each decoded value with an equal but distinct one, which cost a decode per field and stopped SwiftUI from pruning the view tree that reads it. A field whose raw value is unchanged now keeps the value decoded before, the same way `ExpoFabricView.updateProps` already worked for UIKit views. ([#48426](https://github.com/expo/expo/pull/48426) by [@nishan](https://github.com/intergalacticspacehighway))
+
+### 💡 Others
+
+- Migrated from deprecated react-native-worklets WorkletRuntime API `executeSync` to up-to-date `runSync`. `runSync` is available since 0.7.0. ([#48691](https://github.com/expo/expo/pull/48691) by [@tjzel](https://github.com/tjzel))
+- Added internal `ExpoModulesProviderModuleName` lookup key for `ExpoModulesProvider` class. ([#49539](https://github.com/expo/expo/pull/49539) by [@kudo](https://github.com/kudo))
+
+## 57.0.14 — 2026-08-26
+
+### 🎉 New features
+
+- Added `getNativeRef()` to views created with `requireNativeViewManager`, which returns the underlying host component. ([#48788](https://github.com/expo/expo/pull/48788) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+
+### 🐛 Bug fixes
+
+- [iOS] Measure hosted React Native views where SwiftUI placed them, instead of at their Yoga box. ([#48969](https://github.com/expo/expo/pull/48969) by [@nishan](https://github.com/intergalacticspacehighway))
+- [Android] Measure hosted React Native views where Jetpack Compose placed them, instead of at their Yoga box. ([#48970](https://github.com/expo/expo/pull/48970) by [@nishan](https://github.com/intergalacticspacehighway))
+
 ## 57.0.13 — 2026-08-24
 
 ### 🐛 Bug fixes

package/android/build.gradle

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

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

@@ -1,5 +1,6 @@
 #include "NativeStatePropsGetter.h"
 #include "AndroidExpoViewState.h"
+#include "ContentOriginRegistry.h"
 #include <react/fabric/StateWrapperImpl.h>
 
 #include <react/renderer/core/ConcreteState.h>
@@ -11,6 +12,9 @@ void NativeStatePropsGetter::registerNatives() {
                                       makeNativeMethod("getStateProps", NativeStatePropsGetter::getStateProps),
                                       makeNativeMethod("updateStyleSizeImmediateImpl", NativeStatePropsGetter::updateStyleSizeImmediate),
                                       makeNativeMethod("updateViewSizeImmediateImpl", NativeStatePropsGetter::updateViewSizeImmediate),
+                                      makeNativeMethod("setContentOriginImpl", NativeStatePropsGetter::setContentOrigin),
+                                      makeNativeMethod("clearContentOriginImpl", NativeStatePropsGetter::clearContentOrigin),
+                                      makeNativeMethod("clearAllContentOriginsImpl", NativeStatePropsGetter::clearAllContentOrigins),
                                     });
 }
 
@@ -57,6 +61,31 @@ void NativeStatePropsGetter::updateViewSizeImmediate(
   state->updateState(std::move(newState), react::EventQueue::UpdateMode::unstable_Immediate);
 }
 
+void NativeStatePropsGetter::setContentOrigin(
+  jni::alias_ref<NativeStatePropsGetter::javaobject> self,
+  jint tag,
+  jdouble x,
+  jdouble y
+) {
+  ContentOriginRegistry::set(
+    static_cast<react::Tag>(tag),
+    react::Point{.x = static_cast<react::Float>(x), .y = static_cast<react::Float>(y)}
+  );
+}
+
+void NativeStatePropsGetter::clearContentOrigin(
+  jni::alias_ref<NativeStatePropsGetter::javaobject> self,
+  jint tag
+) {
+  ContentOriginRegistry::clear(static_cast<react::Tag>(tag));
+}
+
+void NativeStatePropsGetter::clearAllContentOrigins(
+  jni::alias_ref<NativeStatePropsGetter::javaobject> self
+) {
+  ContentOriginRegistry::clearAll();
+}
+
 jni::local_ref<jni::JMap<jstring, jobject>> NativeStatePropsGetter::getStateProps(
   jni::alias_ref<NativeStatePropsGetter::javaobject> self,
   jni::alias_ref<jobject> stateWrapper

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

@@ -35,6 +35,23 @@ public:
     jdouble width,
     jdouble height
   );
+
+  // Publishes where Compose actually placed a hosted view inside its `Host`, which Yoga cannot see.
+  static void setContentOrigin(
+    jni::alias_ref<NativeStatePropsGetter::javaobject> self,
+    jint tag,
+    jdouble x,
+    jdouble y
+  );
+
+  static void clearContentOrigin(
+    jni::alias_ref<NativeStatePropsGetter::javaobject> self,
+    jint tag
+  );
+
+  static void clearAllContentOrigins(
+    jni::alias_ref<NativeStatePropsGetter::javaobject> self
+  );
 };
 
 } // namespace expo

package/android/src/main/cpp/worklets/WorkletJSCallInvoker.cpp

@@ -24,10 +24,7 @@ namespace expo {
       return;
     }
 
-    workletRuntime->executeSync([func = std::move(func)](jsi::Runtime &rt) -> jsi::Value {
-      func(rt);
-      return jsi::Value::undefined();
-    });
+    workletRuntime->runSync(func);
   }
 } // namespace expo
 

package/android/src/main/java/expo/modules/kotlin/jni/fabric/NativeStatePropsGetter.kt

@@ -24,6 +24,29 @@ class NativeStatePropsGetter {
     updateViewSizeImmediateImpl(stateWrapper, width, height)
   }
 
+  /**
+   * Publishes where the native layout system placed a hosted view inside its `Host`, keyed by the
+   * view's tag. Read while measuring, so `measure()` reports the position the content occupies
+   * rather than its Yoga box.
+   */
+  fun setContentOrigin(tag: Int, x: Double, y: Double) {
+    setContentOriginImpl(tag, x, y)
+  }
+
+  fun clearContentOrigin(tag: Int) {
+    clearContentOriginImpl(tag)
+  }
+
+  fun clearAllContentOrigins() {
+    clearAllContentOriginsImpl()
+  }
+
+  private external fun setContentOriginImpl(tag: Int, x: Double, y: Double)
+
+  private external fun clearContentOriginImpl(tag: Int)
+
+  private external fun clearAllContentOriginsImpl()
+
   private external fun updateStyleSizeImmediateImpl(
     stateWrapper: Any,
     styleWidth: Double,

package/android/src/main/java/expo/modules/kotlin/views/ShadowNodeProxy.kt

@@ -28,6 +28,20 @@ class ShadowNodeProxy(expoView: ExpoView) {
     }
   }
 
+  /**
+   * Reports where the native layout system drew this view inside its `Host`, in dp relative to the
+   * `Host`'s origin.
+   */
+  fun setContentOrigin(x: Double, y: Double) {
+    val view = weakExpoView.get() ?: return
+    stateUpdater.setContentOrigin(view.id, x, y)
+  }
+
+  fun clearContentOrigin() {
+    val view = weakExpoView.get() ?: return
+    stateUpdater.clearContentOrigin(view.id)
+  }
+
   private fun scheduleFlush(flush: (stateWrapper: Any) -> Unit) {
     pendingFlush = flush
     val view = weakExpoView.get() ?: return

package/build/NativeViewManagerAdapter.native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeViewManagerAdapter.native.d.ts","sourceRoot":"","sources":["../src/NativeViewManagerAdapter.native.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAkB,KAAK,aAAa,EAA4B,MAAM,OAAO,CAAC;AA4HrF;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,GAChB,aAAa,CAAC,CAAC,CAAC,CAsClB"}
+{"version":3,"file":"NativeViewManagerAdapter.native.d.ts","sourceRoot":"","sources":["../src/NativeViewManagerAdapter.native.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAkB,KAAK,aAAa,EAA4B,MAAM,OAAO,CAAC;AA4HrF;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,GAChB,aAAa,CAAC,CAAC,CAAC,CA6ClB"}

package/common/cpp/fabric/ContentOriginRegistry.h

@@ -0,0 +1,63 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#ifdef __cplusplus
+
+#include <mutex>
+#include <optional>
+#include <unordered_map>
+
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/graphics/Point.h>
+
+namespace expo {
+
+/**
+ Where the native layout system drew a view's contents, keyed by React tag.
+
+ This sits outside the shadow tree on purpose. `ExpoViewState` would be the idiomatic home, but a
+ state update enqueues a commit, and the origin changes on every native layout pass — a commit per
+ pass can re-run layout, move the origin, and commit again. Writing here schedules no work.
+ */
+class ContentOriginRegistry {
+public:
+  static void set(facebook::react::Tag tag, facebook::react::Point origin) {
+    std::lock_guard<std::mutex> lock(mutex());
+    storage()[tag] = origin;
+  }
+
+  static void clear(facebook::react::Tag tag) {
+    std::lock_guard<std::mutex> lock(mutex());
+    storage().erase(tag);
+  }
+
+  static void clearAll() {
+    std::lock_guard<std::mutex> lock(mutex());
+    storage().clear();
+  }
+
+  static std::optional<facebook::react::Point> find(facebook::react::Tag tag) {
+    std::lock_guard<std::mutex> lock(mutex());
+    auto it = storage().find(tag);
+    if (it == storage().end()) {
+      return std::nullopt;
+    }
+    return it->second;
+  }
+
+private:
+  static std::mutex &mutex() {
+    static std::mutex instance;
+    return instance;
+  }
+
+  static std::unordered_map<facebook::react::Tag, facebook::react::Point> &storage() {
+    static std::unordered_map<facebook::react::Tag, facebook::react::Point> instance;
+    return instance;
+  }
+};
+
+} // namespace expo
+
+#endif // __cplusplus

package/common/cpp/fabric/ExpoViewComponentDescriptor.h

@@ -30,6 +30,32 @@ public:
     return std::static_pointer_cast<std::string const>(this->flavor_)->c_str();
   }
 
+  static bool isRNHostView(const react::Props::Shared &props) {
+    // Currently, only RNHostView can have `sizesToContent` set to true.
+    return ShadowNodeType::sizesToContent(props);
+  }
+
+  std::shared_ptr<facebook::react::ShadowNode> createShadowNode(
+    const facebook::react::ShadowNodeFragment &fragment,
+    const facebook::react::ShadowNodeFamily::Shared &family
+  ) const override {
+    if (!isRNHostView(fragment.props)) {
+      return facebook::react::ConcreteComponentDescriptor<ShadowNodeType>::createShadowNode(
+        fragment, family);
+    }
+
+    // Treat RNHostView as a leaf node and measurable node in Yoga, so that it can be measured by its children.
+    auto traits = this->getTraits();
+    traits.set(facebook::react::ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(facebook::react::ShadowNodeTraits::Trait::MeasurableYogaNode);
+
+    auto shadowNode = std::make_shared<ShadowNodeType>(fragment, family, traits);
+
+    this->adopt(*shadowNode);
+
+    return shadowNode;
+  }
+
   void adopt(facebook::react::ShadowNode &shadowNode) const override {
     react_native_assert(dynamic_cast<ShadowNodeType *>(&shadowNode));
 
@@ -81,6 +107,21 @@ public:
       // Updates yoga style from props and sets the node dirty
       snode->updateYogaProps();
     }
+
+    if (isRNHostView(snode->getProps())) {
+      auto const &props = *std::static_pointer_cast<const facebook::react::ViewProps>(
+        snode->getProps());
+      auto &style = const_cast<facebook::yoga::Style &>(props.yogaStyle);
+
+      // If RNHostView has align self set to auto or stretch, we should override it to flex-start so that the node can size itself to its content
+      auto const alignSelf = style.alignSelf();
+
+      if (alignSelf == facebook::yoga::Align::Auto || alignSelf == facebook::yoga::Align::Stretch) {
+        style.setAlignSelf(facebook::yoga::Align::FlexStart);
+        snode->updateYogaProps();
+      }
+    }
+
     facebook::react::ConcreteComponentDescriptor<ShadowNodeType>::adopt(shadowNode);
   }
 };

package/common/cpp/fabric/ExpoViewShadowNode.h

@@ -5,7 +5,13 @@
 #ifdef __cplusplus
 
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/LayoutableShadowNode.h>
 
+#include <algorithm>
+
+#include "ContentOriginRegistry.h"
 #include "ExpoViewEventEmitter.h"
 #include "ExpoViewProps.h"
 #include "ExpoViewState.h"
@@ -51,7 +57,137 @@ public:
     return traits;
   }
 
+  /**
+   Used by `RNHostView`. Reports where this view's contents were actually drawn, for views laid
+   out by SwiftUI or Compose instead of Yoga. Without it `measure()` returns this node's Yoga box,
+   which is not where the hosted content ended up.
+   */
+  facebook::react::Point getContentOriginOffset(bool includeTransform) const override {
+    // A `false` caller is asking for a scroll offset, which this view never has. Only the layout
+    // path passes `true`, and that is the one this override is for.
+    if (!includeTransform) {
+      return ConcreteViewShadowNode::getContentOriginOffset(includeTransform);
+    }
+
+    auto contentOrigin = ContentOriginRegistry::find(this->getTag());
+    if (!contentOrigin) {
+      return ConcreteViewShadowNode::getContentOriginOffset(includeTransform);
+    }
+
+    // `computeRelativeLayoutMetrics` adds this node's own Yoga origin before consulting us, 
+    // so subtract them as we only want content origin to be considered. 
+    // Publish only the part Yoga cannot see: where
+    // the native layout system placed the content inside its host.
+    auto ownOrigin = this->getLayoutMetrics().frame.origin;
+    return {.x = contentOrigin->x - ownOrigin.x, .y = contentOrigin->y - ownOrigin.y};
+  }
+
+  // Currently, only `RNHostView` declares `expoInternalSizeFromChildren`
+  static bool sizesToContent(const react::Props::Shared &props) {
+    auto const *viewProps = dynamic_cast<const ExpoViewProps *>(props.get());
+
+    if (viewProps == nullptr) {
+      return false;
+    }
+
+    auto const it = viewProps->propsMap.find("expoInternalSizeFromChildren");
+    return it != viewProps->propsMap.end() && it->second.isBool() && it->second.getBool();
+  }
+
+  // Yoga calls this method for RNHostView when it has matchContents set
+  react::Size measureContent(
+    const react::LayoutContext &layoutContext,
+    const react::LayoutConstraints &layoutConstraints
+  ) const override {
+    // Return default behavior when RNHostView does not have `sizesToContent` set to true
+    if (!sizesToContent(this->getProps())) {
+      return ConcreteViewShadowNode::measureContent(layoutContext, layoutConstraints);
+    }
+
+    auto const *content = hostedContent();
+
+    if (content == nullptr) {
+      return {};
+    }
+
+    return content->measure(layoutContext, hostedContentConstraints(*content));
+  }
+
+  // We override this so RNHostView can lay out it's children
+  // We marked it as a Leaf node so we need to manually lay out the hosted content
+  void layout(react::LayoutContext layoutContext) override {
+    ConcreteViewShadowNode::layout(layoutContext);
+
+    if (!sizesToContent(this->getProps())) {
+      return;
+    }
+
+    auto const *content = hostedContent();
+
+    if (content == nullptr) {
+      return;
+    }
+
+    // Use the same constraint that was used to measure the content, so that the layout is consistent with the measurement
+    auto const clonedContent = content->clone({});
+    static_cast<react::LayoutableShadowNode &>(*clonedContent).layoutTree(
+      layoutContext,
+      hostedContentConstraints(*content)
+    );
+
+    this->replaceChild(*content, clonedContent, 0);
+
+    if (layoutContext.affectedNodes != nullptr) {
+      layoutContext.affectedNodes->push_back(
+        static_cast<const react::LayoutableShadowNode *>(clonedContent.get()));
+    }
+  }
+
 private:
+  const react::LayoutableShadowNode *hostedContent() const {
+    auto const &children = this->getChildren();
+
+    return children.empty()
+      ? nullptr
+      : dynamic_cast<const react::LayoutableShadowNode *>(children.front().get());
+  }
+
+  react::LayoutDirection resolvedLayoutDirection() const {
+    return YGNodeLayoutGetDirection(&this->yogaNode_) == YGDirectionRTL
+      ? react::LayoutDirection::RightToLeft
+      : react::LayoutDirection::LeftToRight;
+  }
+
+  react::LayoutConstraints hostedContentConstraints(const react::ShadowNode &content) const {
+    react::LayoutConstraints constraints{};
+    constraints.layoutDirection = resolvedLayoutDirection();
+
+    auto const *contentProps = dynamic_cast<const react::ViewProps *>(content.getProps().get());
+
+    if (contentProps == nullptr) {
+      return constraints;
+    }
+
+    auto const &style = contentProps->yogaStyle;
+
+    constrainToPoints(style.minDimension(facebook::yoga::Dimension::Width),
+                      constraints.minimumSize.width);
+    constrainToPoints(style.minDimension(facebook::yoga::Dimension::Height),
+                      constraints.minimumSize.height);
+    constrainToPoints(style.maxDimension(facebook::yoga::Dimension::Width),
+                      constraints.maximumSize.width);
+    constrainToPoints(style.maxDimension(facebook::yoga::Dimension::Height),
+                      constraints.maximumSize.height);
+
+    return constraints;
+  }
+
+  static void constrainToPoints(facebook::yoga::StyleSizeLength length, react::Float &constraint) {
+    if (length.isPoints() && length.value().isDefined()) {
+      constraint = std::max<react::Float>(0, length.value().unwrap());
+    }
+  }
+
   void initialize() noexcept {
     auto &viewProps = static_cast<const ExpoViewProps &>(*this->props_);
 

package/ios/Core/AppContext.swift

@@ -724,12 +724,14 @@ public final class AppContext: NSObject, EXAppContextProtocol, @unchecked Sendab
    */
   @objc
   public static func modulesProvider(withName providerName: String = "ExpoModulesProvider") -> ModulesProvider {
-    // [0] When ExpoModulesCore is built as separated framework/module,
-    // we should explicitly load main bundle's `ExpoModulesProvider` class.
-    // CFBundleExecutable is tried first: it is the product name, from which the Swift module
-    // name is derived. CFBundleName is kept as a fallback for the uncommon case where both
-    // values are identical valid identifiers.
+    // [0] When ExpoModulesCore is built as a separate framework/module,
+    // explicitly load the main bundle's `ExpoModulesProvider` class.
+    // `ExpoModulesProviderModuleName` is an internal key that allows repack-app to
+    // preserve the original Swift module name. Try `CFBundleExecutable` next because
+    // it usually matches the Swift module name. Keep `CFBundleName` as a final fallback
+    // for cases where it is also a valid module identifier.
     let mainBundleNames = [
+      Bundle.main.infoDictionary?["ExpoModulesProviderModuleName"],
       Bundle.main.infoDictionary?["CFBundleExecutable"],
       Bundle.main.infoDictionary?["CFBundleName"]
     ].compactMap { $0 as? String }

package/ios/Core/Conversions.swift

@@ -34,6 +34,23 @@ public struct Conversions {
     }
   }
 
+  /**
+   Compares two prop values for equality, to tell an actual prop change from a re-delivery of the
+   same value.
+   */
+  static func areValuesEqual(_ lhs: Any?, _ rhs: Any?) -> Bool {
+    switch (lhs, rhs) {
+    case (nil, nil):
+      return true
+    case let (lhsValue as AnyHashable, rhsValue as AnyHashable):
+      return lhsValue == rhsValue
+    case let (lhsValue as NSObjectProtocol, rhsValue as NSObjectProtocol):
+      return lhsValue.isEqual(rhsValue)
+    default:
+      return false
+    }
+  }
+
   static func fromNSObject(_ object: Any) -> Any {
     switch object {
     case let object as NSArray:

package/ios/Core/Views/SwiftUI/SwiftUIShadowNodeProxy.swift

@@ -12,5 +12,8 @@ extension ExpoSwiftUI {
 
     public var setViewSize: ((CGSize) -> Void)?
     public var setStyleSize: ((NSNumber?, NSNumber?) -> Void)?
+    // Where the native layout system drew this view's contents, relative to its host.
+    public var setContentOrigin: ((CGPoint) -> Void)?
+    public var clearContentOrigin: (() -> Void)?
   }
 }

package/ios/Core/Views/SwiftUI/SwiftUIViewProps.swift

@@ -47,9 +47,31 @@ extension ExpoSwiftUI {
      */
     public let globalEventDispatcher = EventDispatcher(GLOBAL_EVENT_NAME)
 
+    /**
+     A dictionary to store previous raw prop values for change detection.
+     */
+    private var previousRawProps: [String: Any] = [:]
+
     internal func updateRawProps(_ rawProps: [String: Any], appContext: AppContext) throws {
-      // Update the props just like the records
-      try update(withDict: rawProps, appContext: appContext)
+      try fieldsOf(self).forEach { field in
+        guard let key = field.key else {
+          return
+        }
+        guard rawProps.keys.contains(key) else {
+          if field.isRequired {
+            try field.set(nil, appContext: appContext)
+          }
+          return
+        }
+        let newValue = rawProps[key]
+        let previousValue = previousRawProps[key]
+
+        if !Conversions.areValuesEqual(previousValue, newValue) {
+          try field.set(newValue, appContext: appContext)
+
+          previousRawProps[key] = newValue
+        }
+      }
 
       // Notify subscribed views about the change to re-render them.
       objectWillChange.send()

package/ios/Core/Views/SwiftUI/SwiftUIVirtualView.swift

@@ -51,6 +51,12 @@ extension ExpoSwiftUI {
       props.shadowNodeProxy.setStyleSize = { [weak self] width, height in
         self?.setStyleSize(width, height: height)
       }
+      props.shadowNodeProxy.setContentOrigin = { [weak self] origin in
+        self?.setContentOrigin(origin)
+      }
+      props.shadowNodeProxy.clearContentOrigin = { [weak self] in
+        self?.clearContentOrigin()
+      }
 
       installEventDispatchers()
     }
@@ -213,6 +219,12 @@ extension ExpoSwiftUI {
       props.shadowNodeProxy.setStyleSize = { [weak self] width, height in
         self?.setStyleSize(width, height: height)
       }
+      props.shadowNodeProxy.setContentOrigin = { [weak self] origin in
+        self?.setContentOrigin(origin)
+      }
+      props.shadowNodeProxy.clearContentOrigin = { [weak self] in
+        self?.clearContentOrigin()
+      }
 
       installEventDispatchers()
     }

package/ios/Core/Views/SwiftUI/SwiftUIVirtualViewObjC.h

@@ -14,6 +14,15 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic) NSInteger tag;
 @property (nonatomic, copy, nullable) NSString *componentName;
 
+/**
+ The tag this view last published a content origin under.
+
+ React Native zeroes `tag` when it recycles a component view, and it does so *before* calling
+ `prepareForRecycle` or `invalidate`, so a teardown hook cannot use `tag` to find its own registry
+ entry. Remembering it here is what lets the entry be removed rather than leaked.
+ */
+@property (nonatomic) NSInteger publishedContentOriginTag;
+
 - (void)dispatchEvent:(nonnull NSString *)eventName payload:(nullable id)payload;
 
 - (void)updateProps:(nonnull NSDictionary<NSString *, id> *)props NS_SWIFT_UI_ACTOR;
@@ -24,6 +33,14 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)setStyleSize:(nullable NSNumber *)width height:(nullable NSNumber *)height;
 
+/**
+ Publishes where SwiftUI drew this view's contents, relative to its host, so `measure()` matches
+ what is on screen. Pass `CGPointZero`-equivalent by calling `clearContentOrigin`.
+ */
+- (void)setContentOrigin:(CGPoint)contentOrigin;
+
+- (void)clearContentOrigin;
+
 - (BOOL)supportsPropWithName:(nonnull NSString *)name;
 
 /*

package/ios/Core/Views/SwiftUI/SwiftUIVirtualViewObjCDev.h

@@ -17,6 +17,15 @@ NS_ASSUME_NONNULL_BEGIN
 // `tag` is inherited from UIView
 @property (nonatomic, copy, nullable) NSString *componentName;
 
+/**
+ The tag this view last published a content origin under.
+
+ React Native zeroes `tag` when it recycles a component view, and it does so *before* calling
+ `prepareForRecycle` or `invalidate`, so a teardown hook cannot use `tag` to find its own registry
+ entry. Remembering it here is what lets the entry be removed rather than leaked.
+ */
+@property (nonatomic) NSInteger publishedContentOriginTag;
+
 - (void)dispatchEvent:(nonnull NSString *)eventName payload:(nullable id)payload;
 
 - (void)updateProps:(nonnull NSDictionary<NSString *, id> *)props NS_SWIFT_UI_ACTOR;
@@ -27,6 +36,10 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)setStyleSize:(nullable NSNumber *)width height:(nullable NSNumber *)height;
 
+- (void)setContentOrigin:(CGPoint)contentOrigin;
+
+- (void)clearContentOrigin;
+
 - (BOOL)supportsPropWithName:(nonnull NSString *)name;
 
 /*

package/ios/Core/Views/SwiftUI/SwiftUIVirtualViewSharedImpl+Private.h

@@ -98,6 +98,7 @@ namespace react = facebook::react;
 - (void)prepareForRecycle
 {
   // Default implementation does nothing.
+  [self clearContentOrigin];
   _eventEmitter.reset();
 }
 
@@ -186,6 +187,23 @@ namespace react = facebook::react;
   }
 }
 
+- (void)setContentOrigin:(CGPoint)contentOrigin
+{
+  self.publishedContentOriginTag = self.tag;
+  expo::ContentOriginRegistry::set(
+    (react::Tag)self.tag,
+    react::Point{.x = (react::Float)contentOrigin.x, .y = (react::Float)contentOrigin.y});
+}
+
+- (void)clearContentOrigin
+{
+  // Not `self.tag`: by the time a teardown hook runs, React Native has already zeroed it.
+  if (self.publishedContentOriginTag != 0) {
+    expo::ContentOriginRegistry::clear((react::Tag)self.publishedContentOriginTag);
+    self.publishedContentOriginTag = 0;
+  }
+}
+
 - (BOOL)supportsPropWithName:(nonnull NSString *)name
 {
   // Implemented in `SwiftUIVirtualView.swift`

package/ios/Fabric/EXContentOriginRegistry.h

@@ -0,0 +1,17 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+NS_SWIFT_NAME(ContentOriginRegistry)
+@interface EXContentOriginRegistry : NSObject
+
+/**
+ Drops every published content origin
+ */
++ (void)clearAll;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Fabric/EXContentOriginRegistry.mm

@@ -0,0 +1,13 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXContentOriginRegistry.h>
+#import <ExpoModulesCore/ContentOriginRegistry.h>
+
+@implementation EXContentOriginRegistry
+
++ (void)clearAll
+{
+  expo::ContentOriginRegistry::clearAll();
+}
+
+@end

package/ios/Fabric/ExpoFabricView.swift

@@ -91,7 +91,7 @@ open class ExpoFabricView: ExpoFabricViewObjC, AnyExpoView {
       let previousValue = previousProps[key]
 
       // only set the prop if the value has changed
-      if !areValuesEqual(previousValue, convertedNewValue) {
+      if !Conversions.areValuesEqual(previousValue, convertedNewValue) {
         // TODO: @tsapeta: Figure out better way to rethrow errors from here.
         // Adding `throws` keyword to the function results in different
         // method signature in Objective-C. Maybe just call `RCTLogError`?
@@ -102,21 +102,6 @@ open class ExpoFabricView: ExpoFabricViewObjC, AnyExpoView {
     }
   }
 
-  /**
-   Helper function to compare two values for equality using string representation.
-   */
-  private func areValuesEqual(_ lhs: Any?, _ rhs: Any?) -> Bool {
-    switch (lhs, rhs) {
-    case (nil, nil):
-      return true
-    case let (lhsValue as AnyHashable, rhsValue as AnyHashable):
-      return lhsValue == rhsValue
-    case let (lhsValue as NSObjectProtocol, rhsValue as NSObjectProtocol):
-      return lhsValue.isEqual(rhsValue)
-    default:
-      return false
-    }
-  }
   /**
    Calls lifecycle methods registered by `OnViewDidUpdateProps` definition component.
    */

package/ios/WorkletsAdapter/ExpoWorkletsBridgeProvider.mm

@@ -233,7 +233,7 @@ static jsi::Value callWorklet(jsi::Runtime &rt, std::shared_ptr<worklets::Serial
     return;
   }
 
-  workletRuntime->executeSync([worklet, arguments](jsi::Runtime &rt) -> jsi::Value {
+  workletRuntime->runSync([worklet, arguments](jsi::Runtime &rt) -> jsi::Value {
     return callWorklet(rt, worklet, arguments);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "57.0.13",
+  "version": "57.0.15",
   "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.6.1",
-    "expo-modules-jsi": "~57.0.5",
+    "expo-modules-jsi": "~57.0.7",
     "invariant": "^2.2.4"
   },
   "peerDependencies": {
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.3"
   },
-  "gitHead": "52fc013ec8c75e89ba8f83c167e4b6b0416e6bf7",
+  "gitHead": "b76ecf192c5325793bcea31dd9bb8efd91f9ad7f",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",

package/src/NativeViewManagerAdapter.native.tsx

@@ -150,6 +150,13 @@ export function requireNativeViewManager<P>(
       this.nativeTag = findNodeHandle(this.nativeRef.current);
     }
 
+    /**
+     * The underlying host component
+     */
+    getNativeRef(): (Component & ReactNativeElement) | null {
+      return this.nativeRef.current;
+    }
+
     render() {
       return <ReactNativeComponent {...this.props} ref={this.nativeRef} />;
     }