expo-modules-core 57.0.11 → 57.0.12

package/CHANGELOG.md

@@ -10,6 +10,13 @@
 
 ### 💡 Others
 
+## 57.0.12 — 2026-08-20
+
+### 🐛 Bug fixes
+
+- [iOS] Fixed an infinite main-thread layout loop (frozen UI, watchdog kill on backgrounding) when a SwiftUI host with `matchContents` and Yoga persistently disagree on the content size, e.g. with the Button Shapes accessibility setting enabled. Synchronous size commits are now budgeted per run-loop turn; over-budget updates are coalesced on the view and committed asynchronously on the next turn, and no-op size updates no longer dirty the layout. ([#48058](https://github.com/expo/expo/issues/48058), [#48059](https://github.com/expo/expo/pull/48059) by [@focux](https://github.com/focux))
+- [iOS] Fixed the `ExpoModulesProvider` lookup missing the generated class when the app `name` starts with a digit, which registered no native modules and left release builds on a blank screen. ([#48793](https://github.com/expo/expo/pull/48793) by [@expo-bot](https://github.com/expo-bot))
+
 ## 57.0.11 — 2026-08-14
 
 ### 🎉 New features

package/android/build.gradle

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

package/common/cpp/fabric/ExpoViewComponentDescriptor.h

@@ -70,15 +70,19 @@ public:
       bool changedStyle = false;
 
       if (!isnan(styleWidth)) {
-        style.setDimension(facebook::yoga::Dimension::Width,
-                           facebook::yoga::StyleSizeLength::points(styleWidth));
-        changedStyle = true;
+        auto expectedWidth = facebook::yoga::StyleSizeLength::points(styleWidth);
+        if (style.dimension(facebook::yoga::Dimension::Width) != expectedWidth) {
+          style.setDimension(facebook::yoga::Dimension::Width, expectedWidth);
+          changedStyle = true;
+        }
       }
 
       if (!isnan(styleHeight)) {
-        style.setDimension(facebook::yoga::Dimension::Height,
-                           facebook::yoga::StyleSizeLength::points(styleHeight));
-        changedStyle = true;
+        auto expectedHeight = facebook::yoga::StyleSizeLength::points(styleHeight);
+        if (style.dimension(facebook::yoga::Dimension::Height) != expectedHeight) {
+          style.setDimension(facebook::yoga::Dimension::Height, expectedHeight);
+          changedStyle = true;
+        }
       }
 
       // Update yoga props and dirty layout if we changed the style

package/ios/Core/AppContext.swift

@@ -726,9 +726,9 @@ public final class AppContext: NSObject, EXAppContextProtocol, @unchecked Sendab
   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 equals $(PRODUCT_NAME:c99extidentifier) and
-    // directly matches the Swift module name. CFBundleName is kept as a fallback for the
-    // uncommon case where both values are identical valid identifiers.
+    // 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.
     let mainBundleNames = [
       Bundle.main.infoDictionary?["CFBundleExecutable"],
       Bundle.main.infoDictionary?["CFBundleName"]
@@ -765,12 +765,27 @@ public final class AppContext: NSObject, EXAppContextProtocol, @unchecked Sendab
 
   internal static func moduleProviderClassNames(withName providerName: String, bundleNames: [String]) -> [String] {
     var seen = Set<String>()
-    return bundleNames.compactMap { bundleName in
+    return bundleNames.flatMap { [$0, c99ExtendedIdentifier($0)] }.compactMap { bundleName in
       let candidate = "\(bundleName).\(providerName)"
       return seen.insert(candidate).inserted ? candidate : nil
     }
   }
 
+  /**
+   Applies the same substitution as Xcode's `:c99extidentifier` string operator, which derives the
+   default `PRODUCT_MODULE_NAME` (and thus the Swift module name) from `PRODUCT_NAME`. The bundle
+   names above are the raw product name, so the two differ whenever the product name is not a valid
+   C99 identifier — most commonly when the app's `name` starts with a digit, where a product name of
+   `123myapp` compiles into the Swift module `_23myapp`.
+   */
+  internal static func c99ExtendedIdentifier(_ name: String) -> String {
+    var characters = name.map { $0.isLetter || $0.isNumber || $0 == "_" ? $0 : "_" }
+    if let first = characters.first, first.isNumber {
+      characters[0] = "_"
+    }
+    return String(characters)
+  }
+
   public func reloadAppAsync(_ reason: String = "Reload from appContext") {
     if moduleRegistry.has(moduleWithName: "ExpoGo") {
       NotificationCenter.default.post(name: NSNotification.Name(rawValue: "EXReloadActiveAppRequest"), object: nil)

package/ios/Fabric/ExpoFabricViewObjC.h

@@ -54,9 +54,9 @@
 
 - (void)viewDidUpdateProps NS_SWIFT_UI_ACTOR;
 
-- (void)setShadowNodeSize:(float)width height:(float)height;
+- (void)setShadowNodeSize:(float)width height:(float)height NS_SWIFT_UI_ACTOR;
 
-- (void)setStyleSize:(nullable NSNumber *)width height:(nullable NSNumber *)height;
+- (void)setStyleSize:(nullable NSNumber *)width height:(nullable NSNumber *)height NS_SWIFT_UI_ACTOR;
 
 - (BOOL)supportsPropWithName:(nonnull NSString *)name;
 

package/ios/Fabric/ExpoFabricViewObjC.mm

@@ -8,13 +8,86 @@
 #import <ExpoModulesCore/ExpoViewComponentDescriptor.h>
 #import <ExpoModulesCore/EXJSIConversions.h>
 
+#import <React/RCTAssert.h>
 #import <React/RCTComponentViewFactory.h>
 #import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
 
+#include <cmath>
+#include <optional>
+
 using namespace expo;
 
 namespace {
 
+#if REACT_NATIVE_TARGET_VERSION >= 82
+
+/**
+ How many synchronous (`unstable_Immediate`) size commits a single view may issue per
+ main-queue turn. The synchronous mode lets a self-sizing view adopt its measured content
+ size within the current frame, but it is only safe while the measured size and the Yoga
+ layout that results from committing it converge. When they persistently disagree (e.g. the
+ Button Shapes accessibility setting changes how SwiftUI content re-measures under the frame
+ it was granted), every synchronous commit re-triggers a measurement in the same run-loop
+ turn and the feedback becomes an unbounded main-thread loop that freezes the app until the
+ watchdog kills it. Updates over the budget are coalesced locally and committed
+ asynchronously on the next turn, so a non-convergent layout settles across frames instead.
+ */
+constexpr NSUInteger kImmediateSizeUpdateBudgetPerTurn = 2;
+
+/**
+ Size deltas below this threshold (in points) are considered noise (e.g. rounding jitter
+ between the pixel grid and SwiftUI's floating point sizes) and are not re-committed.
+ */
+constexpr float kSizeEpsilon = 0.05f;
+
+struct SizePair {
+  float width;
+  float height;
+};
+
+bool nearlyEqualSize(float a, float b)
+{
+  if (std::isnan(a) || std::isnan(b)) {
+    return std::isnan(a) && std::isnan(b);
+  }
+  if (a == b) {
+    return true;
+  }
+  return std::fabs(a - b) <= kSizeEpsilon;
+}
+
+bool nearlyEqualSize(const SizePair &a, const SizePair &b)
+{
+  return nearlyEqualSize(a.width, b.width) && nearlyEqualSize(a.height, b.height);
+}
+
+/**
+ A pending size update. Each channel maps to the corresponding pair of `ExpoViewState`
+ fields; merging keeps the latest value per channel so deferred updates cannot erase
+ the other channel (unlike replacing the whole state).
+ */
+struct SizeStatePatch {
+  std::optional<SizePair> shadowDimensions;
+  std::optional<SizePair> styleDimensions;
+
+  bool empty() const
+  {
+    return !shadowDimensions && !styleDimensions;
+  }
+
+  void merge(const SizeStatePatch &newer)
+  {
+    if (newer.shadowDimensions) {
+      shadowDimensions = newer.shadowDimensions;
+    }
+    if (newer.styleDimensions) {
+      styleDimensions = newer.styleDimensions;
+    }
+  }
+};
+
+#endif // REACT_NATIVE_TARGET_VERSION >= 82
+
 id convertFollyDynamicToId(const folly::dynamic &dyn)
 {
   // I could imagine an implementation which avoids copies by wrapping the
@@ -79,6 +152,14 @@ static std::unordered_map<std::string, ExpoViewComponentDescriptor<>::Flavor> _c
 
 @implementation ExpoFabricViewObjC {
   ExpoViewShadowNode<>::ConcreteState::Shared _state;
+#if REACT_NATIVE_TARGET_VERSION >= 82
+  NSUInteger _immediateSizeUpdatesInTurn;
+  BOOL _sizeGuardResetScheduled;
+  uint64_t _sizeGuardGeneration;
+  std::optional<SizePair> _lastShadowSizeRequestInTurn;
+  std::optional<SizePair> _lastStyleSizeRequestInTurn;
+  SizeStatePatch _deferredSizePatch;
+#endif
 }
 
 - (instancetype)initWithFrame:(CGRect)frame
@@ -170,15 +251,141 @@ static std::unordered_map<std::string, ExpoViewComponentDescriptor<>::Flavor> _c
 
 - (void)setShadowNodeSize:(float)width height:(float)height
 {
-  if (_state) {
 #if REACT_NATIVE_TARGET_VERSION >= 82
-    _state->updateState(ExpoViewState(width,height), react::EventQueue::UpdateMode::unstable_Immediate);
+  SizeStatePatch patch;
+  patch.shadowDimensions = SizePair{
+    width >= 0 ? width : std::numeric_limits<float>::quiet_NaN(),
+    height >= 0 ? height : std::numeric_limits<float>::quiet_NaN()
+  };
+  [self submitSizePatch:patch];
 #else
-    _state->updateState(ExpoViewState(width,height));
+  if (_state) {
+    _state->updateState(ExpoViewState(width, height));
+  }
 #endif
+}
+
+#if REACT_NATIVE_TARGET_VERSION >= 82
+
+- (void)submitSizePatch:(const SizeStatePatch &)patch
+{
+  RCTAssertMainQueue();
+
+  if (!_state) {
+    return;
+  }
+
+  // Transient per-turn dedup: prevents re-entrant same-size requests from
+  // committing again before `updateState` returns. Cleared every turn, so it
+  // can never go stale across turns.
+  if (patch.shadowDimensions) {
+    if (_lastShadowSizeRequestInTurn && nearlyEqualSize(*_lastShadowSizeRequestInTurn, *patch.shadowDimensions)) {
+      return;
+    }
+    _lastShadowSizeRequestInTurn = *patch.shadowDimensions;
+  }
+  if (patch.styleDimensions) {
+    if (_lastStyleSizeRequestInTurn && nearlyEqualSize(*_lastStyleSizeRequestInTurn, *patch.styleDimensions)) {
+      return;
+    }
+    _lastStyleSizeRequestInTurn = *patch.styleDimensions;
+  }
+
+  if (!_sizeGuardResetScheduled) {
+    _sizeGuardResetScheduled = YES;
+    const uint64_t generation = _sizeGuardGeneration;
+    __weak ExpoFabricViewObjC *weakSelf = self;
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      ExpoFabricViewObjC *strongSelf = weakSelf;
+      if (strongSelf == nil || strongSelf->_sizeGuardGeneration != generation) {
+        return;
+      }
+      strongSelf->_sizeGuardResetScheduled = NO;
+      strongSelf->_immediateSizeUpdatesInTurn = 0;
+      strongSelf->_lastShadowSizeRequestInTurn.reset();
+      strongSelf->_lastStyleSizeRequestInTurn.reset();
+
+      SizeStatePatch pending = strongSelf->_deferredSizePatch;
+      strongSelf->_deferredSizePatch = {};
+
+      if (!pending.empty()) {
+        // Deliberately entered into React Native's event queue only now: an
+        // `unstable_Immediate` update from any other view flushes the whole
+        // shared queue synchronously, which would pull an "asynchronous"
+        // update enqueued during the previous turn right back into the
+        // feedback loop this guard is breaking.
+        [strongSelf dispatchSizePatch:pending updateMode:react::EventQueue::UpdateMode::Asynchronous];
+      }
+    });
+  }
+
+  if (_immediateSizeUpdatesInTurn < kImmediateSizeUpdateBudgetPerTurn) {
+    _immediateSizeUpdatesInTurn++;
+    [self dispatchSizePatch:patch updateMode:react::EventQueue::UpdateMode::unstable_Immediate];
+  } else {
+    _deferredSizePatch.merge(patch);
   }
 }
 
+- (void)dispatchSizePatch:(const SizeStatePatch &)patch updateMode:(react::EventQueue::UpdateMode)updateMode
+{
+  const auto state = _state;
+  if (!state) {
+    return;
+  }
+
+  state->updateState(
+    [patch](const ExpoViewState &oldData) -> ExpoViewShadowNode<>::ConcreteState::SharedData {
+      ExpoViewState newData = oldData;
+      bool changed = false;
+
+      if (patch.shadowDimensions &&
+          !(nearlyEqualSize(oldData._width, patch.shadowDimensions->width) &&
+            nearlyEqualSize(oldData._height, patch.shadowDimensions->height))) {
+        newData._width = patch.shadowDimensions->width;
+        newData._height = patch.shadowDimensions->height;
+        changed = true;
+      }
+      if (patch.styleDimensions &&
+          !(nearlyEqualSize(oldData._styleWidth, patch.styleDimensions->width) &&
+            nearlyEqualSize(oldData._styleHeight, patch.styleDimensions->height))) {
+        newData._styleWidth = patch.styleDimensions->width;
+        newData._styleHeight = patch.styleDimensions->height;
+        changed = true;
+      }
+
+      // Returning nullptr cancels the commit before any layout work happens,
+      // so a no-op size update cannot dirty the tree.
+      return changed ? std::make_shared<const ExpoViewState>(newData) : nullptr;
+    },
+    updateMode);
+}
+
+- (void)resetSizeUpdateGuard
+{
+  _sizeGuardGeneration++;
+  _immediateSizeUpdatesInTurn = 0;
+  _sizeGuardResetScheduled = NO;
+  _lastShadowSizeRequestInTurn.reset();
+  _lastStyleSizeRequestInTurn.reset();
+  _deferredSizePatch = {};
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  [self resetSizeUpdateGuard];
+}
+
+- (void)invalidate
+{
+  [super invalidate];
+  [self resetSizeUpdateGuard];
+}
+
+#endif // REACT_NATIVE_TARGET_VERSION >= 82
+
 - (BOOL)supportsPropWithName:(nonnull NSString *)name
 {
   // Implemented in `ExpoFabricView.swift`
@@ -187,16 +394,20 @@ static std::unordered_map<std::string, ExpoViewComponentDescriptor<>::Flavor> _c
 
 - (void)setStyleSize:(nullable NSNumber *)width height:(nullable NSNumber *)height
 {
-  if (_state) {
-    float widthValue = width ? [width floatValue] : std::numeric_limits<float>::quiet_NaN();
-    float heightValue = height ? [height floatValue] : std::numeric_limits<float>::quiet_NaN();
+  float widthValue = width ? [width floatValue] : std::numeric_limits<float>::quiet_NaN();
+  float heightValue = height ? [height floatValue] : std::numeric_limits<float>::quiet_NaN();
 #if REACT_NATIVE_TARGET_VERSION >= 82
-    // synchronous update is only available in React Native 0.82 and above
-    _state->updateState(expo::ExpoViewState::withStyleDimensions(widthValue, heightValue), react::EventQueue::UpdateMode::unstable_Immediate);
+  SizeStatePatch patch;
+  patch.styleDimensions = SizePair{
+    widthValue >= 0 ? widthValue : std::numeric_limits<float>::quiet_NaN(),
+    heightValue >= 0 ? heightValue : std::numeric_limits<float>::quiet_NaN()
+  };
+  [self submitSizePatch:patch];
 #else
+  if (_state) {
     _state->updateState(expo::ExpoViewState::withStyleDimensions(widthValue, heightValue));
-#endif
   }
+#endif
 }
 
 #pragma mark - Component registration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "57.0.11",
+  "version": "57.0.12",
   "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.4",
+    "expo-modules-jsi": "~57.0.5",
     "invariant": "^2.2.4"
   },
   "peerDependencies": {
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.3"
   },
-  "gitHead": "125b8d4472432db3dc4ae047730432d7bd5bd30c",
+  "gitHead": "499024a441d67293aa60afcbe02051999a54f1bb",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",