expo 57.0.9 → 57.0.11

package/android/build.gradle

@@ -10,7 +10,7 @@ buildscript {
 }
 
 group = 'host.exp.exponent'
-version = '57.0.9'
+version = '57.0.11'
 
 expoModule {
   // We can't prebuild the module because it depends on the generated files.
@@ -21,7 +21,7 @@ android {
   namespace "expo.core"
   defaultConfig {
     versionCode 1
-    versionName "57.0.9"
+    versionName "57.0.11"
     consumerProguardFiles("proguard-rules.pro")
   }
   testOptions {

package/build/winter/fetch/FetchResponse.d.ts

@@ -10,7 +10,24 @@ declare const stateKey: unique symbol;
 export declare class FetchResponse extends ConcreteNativeResponse implements Response {
     private readonly abortCleanupFunction;
     private [stateKey];
+    private bodyStreamClosed;
+    private bodyStreamController;
+    private abortReason;
     constructor(abortCleanupFunction: AbortSubscriptionCleanupFunction);
+    /**
+     * Rejects the pending body read with the abort reason and closes the
+     * teardown guard so late native events are dropped (#34804). Idempotent,
+     * and safe to call before the body stream exists.
+     */
+    abort(reason?: unknown): void;
+    /**
+     * These helpers run on the native emitter's stack, where a throw reaches the
+     * global handler. The guard can be stale (internal stream errors bypass
+     * `controller.error()`), so check `desiredSize` (null = errored) and catch.
+     */
+    private closeBodyStream;
+    private errorBodyStream;
+    private enqueueBodyChunk;
     get _rawHeaders(): NativeHeadersType;
     get status(): number;
     get statusText(): string;

package/build/winter/fetch/FetchResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FetchResponse.d.ts","sourceRoot":"","sources":["../../../src/winter/fetch/FetchResponse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGzE,QAAA,MAAM,sBAAsB,EAAqC,OAAO,cAAc,CAAC;AACvF,MAAM,MAAM,gCAAgC,GAAG,MAAM,IAAI,CAAC;AAI1D,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AACvE,KAAK,iBAAiB,GAAG,UAAU,CAAC,QAAQ,GAAG,UAAU,CAAC;AAW1D,QAAA,MAAM,QAAQ,eAAgC,CAAC;AAuI/C;;GAEG;AACH,qBAAa,aAAc,SAAQ,sBAAuB,YAAW,QAAQ;IAM/D,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IALjD,OAAO,CAAC,CAAC,QAAQ,CAAC,CAGhB;gBAE2B,oBAAoB,EAAE,gCAAgC;IAQnF,IAAa,WAAW,IAAI,iBAAiB,CAE5C;IAED,IAAa,MAAM,IAAI,MAAM,CAE5B;IAED,IAAa,UAAU,IAAI,MAAM,CAEhC;IAED,IAAa,GAAG,IAAI,MAAM,CAEzB;IAED,IAAa,UAAU,IAAI,OAAO,CAEjC;IAED,IAAI,IAAI,IAAI,SAAS,CAEpB;IAED,IAAI,IAAI,IAAI,cAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI,CA0EzD;IAED,IAAa,QAAQ,IAAI,OAAO,CAE/B;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,EAAE,IAAI,OAAO,CAEhB;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBrB,QAAQ,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAgBtC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC;IAMpB,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAKhC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAanC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAatC,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,MAAM;IAShB,KAAK,IAAI,aAAa;IAgDtB,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,QAAQ,CAQd;CACH"}
+{"version":3,"file":"FetchResponse.d.ts","sourceRoot":"","sources":["../../../src/winter/fetch/FetchResponse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGzE,QAAA,MAAM,sBAAsB,EAAqC,OAAO,cAAc,CAAC;AACvF,MAAM,MAAM,gCAAgC,GAAG,MAAM,IAAI,CAAC;AAI1D,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AACvE,KAAK,iBAAiB,GAAG,UAAU,CAAC,QAAQ,GAAG,UAAU,CAAC;AAW1D,QAAA,MAAM,QAAQ,eAAgC,CAAC;AAuI/C;;GAEG;AACH,qBAAa,aAAc,SAAQ,sBAAuB,YAAW,QAAQ;IAa/D,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IAZjD,OAAO,CAAC,CAAC,QAAQ,CAAC,CAGhB;IAIF,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,oBAAoB,CACrB;IACP,OAAO,CAAC,WAAW,CAAsB;gBAEZ,oBAAoB,EAAE,gCAAgC;IAKnF;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAmB7B;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,gBAAgB;IAkBxB,IAAa,WAAW,IAAI,iBAAiB,CAE5C;IAED,IAAa,MAAM,IAAI,MAAM,CAE5B;IAED,IAAa,UAAU,IAAI,MAAM,CAEhC;IAED,IAAa,GAAG,IAAI,MAAM,CAEzB;IAED,IAAa,UAAU,IAAI,OAAO,CAEjC;IAED,IAAI,IAAI,IAAI,SAAS,CAEpB;IAED,IAAI,IAAI,IAAI,cAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI,CAoEzD;IAED,IAAa,QAAQ,IAAI,OAAO,CAE/B;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,EAAE,IAAI,OAAO,CAEhB;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBrB,QAAQ,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAgBtC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC;IAMpB,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAKhC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAanC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAatC,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,MAAM;IAShB,KAAK,IAAI,aAAa;IAgDtB,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,QAAQ,CAQd;CACH"}

package/build/winter/fetch/fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../src/winter/fetch/fetch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAyC,MAAM,iBAAiB,CAAC;AAQvF,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAwBxE,wBAAsB,KAAK,CACzB,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,gBAAgB,EACtC,IAAI,CAAC,EAAE,gBAAgB,GACtB,OAAO,CAAC,aAAa,CAAC,CAuDxB"}
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../src/winter/fetch/fetch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAyC,MAAM,iBAAiB,CAAC;AAQvF,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAwBxE,wBAAsB,KAAK,CACzB,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,gBAAgB,EACtC,IAAI,CAAC,EAAE,gBAAgB,GACtB,OAAO,CAAC,aAAa,CAAC,CA0DxB"}

package/bundledNativeModules.json

@@ -3,7 +3,7 @@
   "@expo/fingerprint": "~0.20.6",
   "@expo/metro-runtime": "~57.0.8",
   "@expo/vector-icons": "^15.0.2",
-  "@expo/ui": "~57.0.8",
+  "@expo/ui": "~57.0.9",
   "@react-native-async-storage/async-storage": "2.2.0",
   "@react-native-community/datetimepicker": "9.1.0",
   "@react-native-masked-view/masked-view": "0.3.2",
@@ -17,85 +17,85 @@
   "expo-analytics-amplitude": "~11.3.0",
   "expo-app-auth": "~11.1.0",
   "expo-app-loader-provider": "~8.0.0",
-  "expo-app-metrics": "~57.0.7",
+  "expo-app-metrics": "~57.0.9",
   "expo-apple-authentication": "~57.0.1",
   "expo-application": "~57.0.2",
-  "expo-asset": "~57.0.8",
+  "expo-asset": "~57.0.9",
   "expo-audio": "~57.0.3",
-  "expo-auth-session": "~57.0.5",
-  "expo-background-fetch": "~57.0.7",
-  "expo-background-task": "~57.0.7",
+  "expo-auth-session": "~57.0.6",
+  "expo-background-fetch": "~57.0.8",
+  "expo-background-task": "~57.0.8",
   "expo-battery": "~57.0.1",
   "expo-blur": "~57.0.2",
   "expo-brightness": "~57.0.1",
-  "expo-brownfield": "~57.0.8",
-  "expo-build-properties": "~57.0.8",
+  "expo-brownfield": "~57.0.9",
+  "expo-build-properties": "~57.0.9",
   "expo-calendar": "~57.0.1",
   "expo-camera": "~57.0.3",
   "expo-cellular": "~57.0.1",
   "expo-checkbox": "~57.0.0",
   "expo-clipboard": "~57.0.1",
-  "expo-constants": "~57.0.8",
+  "expo-constants": "~57.0.9",
   "expo-contacts": "~57.0.3",
   "expo-crypto": "~57.0.1",
   "expo-dev-client": "~57.0.10",
   "expo-device": "~57.0.1",
   "expo-document-picker": "~57.0.1",
   "expo-eas-client": "~57.0.1",
-  "expo-file-system": "~57.0.1",
+  "expo-file-system": "~57.0.2",
   "expo-font": "~57.0.1",
   "expo-gl": "~57.0.2",
   "expo-glass-effect": "~57.0.1",
   "expo-google-app-auth": "~8.3.0",
   "expo-haptics": "~57.0.1",
-  "expo-image": "~57.0.1",
+  "expo-image": "~57.0.2",
   "expo-image-loader": "~57.0.1",
-  "expo-image-manipulator": "~57.0.7",
-  "expo-image-picker": "~57.0.7",
+  "expo-image-manipulator": "~57.0.8",
+  "expo-image-picker": "~57.0.8",
   "expo-intent-launcher": "~57.0.1",
-  "expo-insights": "~57.0.7",
+  "expo-insights": "~57.0.8",
   "expo-keep-awake": "~57.0.1",
   "expo-linear-gradient": "~57.0.1",
-  "expo-linking": "~57.0.4",
+  "expo-linking": "~57.0.5",
   "expo-local-authentication": "~57.0.2",
   "expo-localization": "~57.0.1",
-  "expo-location": "~57.0.7",
+  "expo-location": "~57.0.8",
   "expo-mail-composer": "~57.0.1",
   "expo-manifests": "~57.0.1",
   "expo-maps": "~57.0.1",
   "expo-mcp": "~0.2.1",
   "expo-media-library": "~57.0.3",
   "expo-mesh-gradient": "~57.0.1",
-  "expo-module-template": "~57.0.5",
-  "expo-modules-core": "~57.0.8",
+  "expo-module-template": "~57.0.6",
+  "expo-modules-core": "~57.0.10",
   "expo-navigation-bar": "~57.0.2",
   "expo-network": "~57.0.1",
-  "expo-notifications": "~57.0.8",
-  "expo-observe": "~57.0.9",
+  "expo-notifications": "~57.0.9",
+  "expo-observe": "~57.0.11",
   "expo-print": "~57.0.1",
   "expo-live-photo": "~57.0.1",
-  "expo-router": "~57.0.9",
+  "expo-router": "~57.0.11",
   "expo-screen-capture": "~57.0.1",
   "expo-screen-orientation": "~57.0.1",
   "expo-secure-store": "~57.0.1",
   "expo-sensors": "~57.0.2",
   "expo-server": "~57.0.1",
-  "expo-sharing": "~57.0.8",
+  "expo-sharing": "~57.0.9",
   "expo-sms": "~57.0.1",
   "expo-speech": "~57.0.1",
   "expo-splash-screen": "~57.0.5",
   "expo-sqlite": "~57.0.1",
   "expo-status-bar": "~57.0.1",
   "expo-store-review": "~57.0.1",
-  "expo-symbols": "~57.0.1",
+  "expo-symbols": "~57.0.2",
   "expo-system-ui": "~57.0.2",
-  "expo-task-manager": "~57.0.7",
+  "expo-task-manager": "~57.0.8",
   "expo-tracking-transparency": "~57.0.1",
-  "expo-updates": "~57.0.11",
+  "expo-updates": "~57.0.12",
   "expo-video-thumbnails": "~57.0.1",
   "expo-video": "~57.0.2",
   "expo-web-browser": "~57.0.2",
-  "expo-widgets": "~57.0.7",
+  "expo-widgets": "~57.0.8",
   "jest-expo": "~57.0.3",
   "lottie-react-native": "~7.3.8",
   "react": "19.2.3",

package/ios/Fetch/NativeResponse.swift

@@ -129,32 +129,50 @@ internal final class NativeResponse: SharedObject, ExpoURLSessionTaskDelegate, @
 
   // MARK: - ExpoURLSessionTaskDelegate implementations
 
+  // URLSession runs these callbacks on its own queue, racing `state` / sink access on `dispatchQueue`.
+  // Hop every callback onto `dispatchQueue` to serialize the whole state machine on one queue.
+
   func urlSessionDidStart(_ session: ExpoURLSessionTask) {
-    if isInvalidState(.intialized) {
-      return
+    dispatchQueue.async { [weak self] in
+      guard let self else {
+        return
+      }
+      if self.isInvalidState(.intialized) {
+        return
+      }
+      self.state = .started
     }
-    state = .started
   }
 
   func urlSession(_ session: ExpoURLSessionTask, didReceive response: URLResponse) {
-    if isInvalidState(.started) {
-      return
+    dispatchQueue.async { [weak self] in
+      guard let self else {
+        return
+      }
+      if self.isInvalidState(.started) {
+        return
+      }
+      self.responseInit = Self.createResponseInit(response: response)
+      self.state = .responseReceived
     }
-    responseInit = Self.createResponseInit(response: response)
-    state = .responseReceived
   }
 
   func urlSession(_ session: ExpoURLSessionTask, didReceive data: Data) {
-    if isInvalidState(.responseReceived, .bodyStreamingStarted, .bodyStreamingCanceled) {
-      return
-    }
+    dispatchQueue.async { [weak self] in
+      guard let self else {
+        return
+      }
+      if self.isInvalidState(.responseReceived, .bodyStreamingStarted, .bodyStreamingCanceled) {
+        return
+      }
 
-    if state == .responseReceived {
-      self.sink.appendBufferBody(data: data)
-    } else if state == .bodyStreamingStarted {
-      emit(event: "didReceiveResponseData", payload: data)
+      if self.state == .responseReceived {
+        self.sink.appendBufferBody(data: data)
+      } else if self.state == .bodyStreamingStarted {
+        self.emit(event: "didReceiveResponseData", payload: data)
+      }
+      // no-op in .bodyStreamingCanceled state
     }
-    // no-op in .bodyStreamingCanceled state
   }
 
   func urlSession(
@@ -164,22 +182,37 @@ internal final class NativeResponse: SharedObject, ExpoURLSessionTaskDelegate, @
     newRequest request: URLRequest,
     completionHandler: @escaping (URLRequest?) -> Void
   ) {
-    let shouldFollowRedirects = self.redirectMode == .follow
-    completionHandler(shouldFollowRedirects ? request : nil)
-    self.redirected = shouldFollowRedirects
+    dispatchQueue.async { [weak self] in
+      guard let self else {
+        completionHandler(nil)
+        return
+      }
+      let shouldFollowRedirects = self.redirectMode == .follow
+      completionHandler(shouldFollowRedirects ? request : nil)
+      self.redirected = shouldFollowRedirects
 
-    if self.redirectMode == .error {
-      let error = FetchRedirectException()
-      self.error = error
-      if state == .bodyStreamingStarted {
-        emit(event: "didFailWithError", payload: error.localizedDescription)
+      if self.redirectMode == .error {
+        let error = FetchRedirectException()
+        self.error = error
+        if self.state == .bodyStreamingStarted {
+          self.emit(event: "didFailWithError", payload: error.localizedDescription)
+        }
+        self.state = .errorReceived
+        self.emit(event: "readyForJSFinalization")
       }
-      state = .errorReceived
-      emit(event: "readyForJSFinalization")
     }
   }
 
   func urlSession(_ session: ExpoURLSessionTask, task: URLSessionTask, didCompleteWithError error: (any Error)?) {
+    dispatchQueue.async { [weak self] in
+      guard let self else {
+        return
+      }
+      self.handleDidCompleteWithError(session: session, task: task, error: error)
+    }
+  }
+
+  private func handleDidCompleteWithError(session: ExpoURLSessionTask, task: URLSessionTask, error: (any Error)?) {
     if isInvalidState(.started, .responseReceived, .bodyStreamingStarted, .bodyStreamingCanceled) {
       return
     }
@@ -202,7 +235,7 @@ internal final class NativeResponse: SharedObject, ExpoURLSessionTaskDelegate, @
         guard let self else {
           return
         }
-        self.urlSession(session, task: task, didCompleteWithError: error)
+        self.handleDidCompleteWithError(session: session, task: task, error: error)
       }
       return
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo",
-  "version": "57.0.9",
+  "version": "57.0.11",
   "description": "The Expo SDK",
   "main": "src/Expo.ts",
   "module": "src/Expo.ts",
@@ -68,9 +68,9 @@
   "homepage": "https://github.com/expo/expo/tree/main/packages/expo",
   "dependencies": {
     "@babel/runtime": "^7.20.0",
-    "@expo/cli": "^57.0.11",
+    "@expo/cli": "^57.0.13",
     "@expo/config": "~57.0.6",
-    "@expo/config-plugins": "~57.0.6",
+    "@expo/config-plugins": "~57.0.7",
     "@expo/devtools": "~57.0.1",
     "@expo/dom-webview": "~57.0.1",
     "@expo/fingerprint": "^0.20.6",
@@ -79,14 +79,14 @@
     "@expo/metro": "~56.0.0",
     "@expo/metro-config": "~57.0.7",
     "@ungap/structured-clone": "^1.3.0",
-    "babel-preset-expo": "~57.0.5",
-    "expo-asset": "~57.0.8",
-    "expo-constants": "~57.0.8",
-    "expo-file-system": "~57.0.1",
+    "babel-preset-expo": "~57.0.6",
+    "expo-asset": "~57.0.9",
+    "expo-constants": "~57.0.9",
+    "expo-file-system": "~57.0.2",
     "expo-font": "~57.0.1",
     "expo-keep-awake": "~57.0.1",
     "expo-modules-autolinking": "~57.0.9",
-    "expo-modules-core": "~57.0.8",
+    "expo-modules-core": "~57.0.10",
     "pretty-format": "^29.7.0",
     "react-refresh": "^0.14.2",
     "whatwg-url-minimum": "^0.1.2"
@@ -102,7 +102,7 @@
     "web-streams-polyfill": "^3.3.2",
     "@expo/dom-webview": "57.0.1",
     "@expo/metro-runtime": "57.0.8",
-    "expo-updates": "57.0.11"
+    "expo-updates": "57.0.12"
   },
   "peerDependencies": {
     "@expo/dom-webview": "*",
@@ -139,7 +139,7 @@
       "scripts/resolveAppEntry.js"
     ]
   },
-  "gitHead": "ff6a677893d78b02c3adf63f67ba159b926395b0",
+  "gitHead": "e322c877a4d185fb18b27d68945a190cb7f15ce6",
   "scripts": {
     "build": "tsc",
     "clean": "rimraf build",

package/src/async-require/__tests__/asyncRequireModule.test.ts

@@ -90,20 +90,9 @@ describe('asyncRequireModule', () => {
 
       function asyncRequire(moduleID, paths, moduleName) {
         var ret = asyncRequireImpl(moduleID, paths, moduleName);
-        if (!(ret instanceof Promise)) {
-          return {
-            _result: ret,
-            then: function(resolve, reject) {
-              return Promise.resolve(ret).then(resolve, reject);
-            },
-          };
-        }
-        return {
-          _result: ret,
-          then: function(resolve, reject) {
-            return ret.then(resolve, reject);
-          },
-        };
+        var promise = Promise.resolve(ret);
+        promise._result = ret;
+        return promise;
       }
 
       asyncRequire.unstable_importMaybeSync = function(moduleID, paths) {
@@ -225,14 +214,20 @@ describe('asyncRequireModule', () => {
   });
 
   describe('thenable return value', () => {
-    it('exposes a synchronous _result when no bundle load was needed', () => {
+    it('returns a Promise with a synchronous _result when no bundle load was needed', async () => {
       const ret = asyncRequire(42, null, 'my-module');
 
-      expect(typeof ret.then).toBe('function');
+      const onFinally = jest.fn();
+
+      expect(ret).toBeInstanceOf(Promise);
+      expect(typeof ret.catch).toBe('function');
+      expect(typeof ret.finally).toBe('function');
       expect(ret._result).toEqual({ default: 'module-42' });
+      await expect(ret.finally(onFinally)).resolves.toEqual({ default: 'module-42' });
+      expect(onFinally).toHaveBeenCalledTimes(1);
     });
 
-    it('exposes a Promise _result when a bundle load was needed', async () => {
+    it('returns a Promise with a Promise _result when a bundle load was needed', async () => {
       process.env.EXPO_OS = 'web';
       mockImportAll
         .mockImplementationOnce(() => {
@@ -244,10 +239,22 @@ describe('asyncRequireModule', () => {
 
       const ret = asyncRequire(42, { '42': '/bundles/my-module.bundle' }, 'my-module');
 
-      expect(typeof ret.then).toBe('function');
+      expect(ret).toBeInstanceOf(Promise);
+      expect(typeof ret.catch).toBe('function');
+      expect(typeof ret.finally).toBe('function');
       expect(ret._result).toBeInstanceOf(Promise);
       await expect(ret._result).resolves.toEqual({ default: 'module-42' });
     });
+
+    it('supports catching a rejected bundle load', async () => {
+      process.env.EXPO_OS = 'ios';
+      const error = new Error('Bundle load failed');
+      (globalThis as any).__loadBundleAsync = jest.fn(() => Promise.reject(error));
+
+      const ret = asyncRequire(42, { '42': '/bundles/my-module.bundle' }, 'my-module');
+
+      await expect(ret.catch((caughtError: Error) => caughtError)).resolves.toBe(error);
+    });
   });
 
   describe('unstable_importMaybeSync', () => {

package/src/async-require/asyncRequireModule.ts

@@ -94,30 +94,22 @@ function asyncRequireImpl<T>(
   return importAll();
 }
 
+type PromiseWithResult<T> = Promise<T> & {
+  _result?: T | Promise<T>;
+};
+
 function asyncRequire<T>(
   moduleID: number,
   paths: DependencyMapPaths,
   moduleName?: string
-): PromiseLike<T> & { _result?: T | Promise<T> } {
+): PromiseWithResult<T> {
   const ret = asyncRequireImpl<T>(moduleID, paths, moduleName);
-  if (!(ret instanceof Promise)) {
-    // We return a thenable with an added `unstable_importMaybeSync`-like
-    // `_result` property to bypass this being force-converted to a promise
-    // for rehydration
-    return {
-      _result: ret,
-      then(resolve, reject) {
-        return Promise.resolve(ret).then(resolve, reject);
-      },
-    };
-  } else {
-    return {
-      _result: ret,
-      then(resolve, reject) {
-        return ret.then(resolve, reject);
-      },
-    };
-  }
+  // We return a Promise with an added `unstable_importMaybeSync`-like
+  // `_result` property to bypass this being force-converted to a promise
+  // for rehydration
+  const promise: PromiseWithResult<T> = Promise.resolve(ret);
+  promise._result = ret;
+  return promise;
 }
 
 // Synchronous version of asyncRequire, which can still return a promise

package/src/winter/fetch/FetchResponse.ts

@@ -163,11 +163,94 @@ export class FetchResponse extends ConcreteNativeResponse implements Response {
     metadata: null,
   };
 
+  // `bodyStreamClosed` is only a fast path — the stream can leave `readable`
+  // without it being set, so every controller call must also ask the controller.
+  private bodyStreamClosed = false;
+  private bodyStreamController: ReadableStreamDefaultController<Uint8Array<ArrayBuffer>> | null =
+    null;
+  private abortReason: unknown = undefined;
+
   constructor(private readonly abortCleanupFunction: AbortSubscriptionCleanupFunction) {
     super();
     this.addListener('readyForJSFinalization', this.finalize);
   }
 
+  /**
+   * Rejects the pending body read with the abort reason and closes the
+   * teardown guard so late native events are dropped (#34804). Idempotent,
+   * and safe to call before the body stream exists.
+   */
+  abort(reason?: unknown): void {
+    const abortError =
+      reason != null
+        ? reason
+        : typeof DOMException !== 'undefined'
+          ? new DOMException('The operation was aborted.', 'AbortError')
+          : Object.assign(new Error('The operation was aborted.'), { name: 'AbortError' });
+    this.abortReason = abortError;
+    if (this.bodyStreamClosed) {
+      return;
+    }
+    this.bodyStreamClosed = true;
+    try {
+      this.bodyStreamController?.error(abortError);
+    } catch {
+      // Controller already closed/errored — nothing to propagate.
+    }
+  }
+
+  /**
+   * These helpers run on the native emitter's stack, where a throw reaches the
+   * global handler. The guard can be stale (internal stream errors bypass
+   * `controller.error()`), so check `desiredSize` (null = errored) and catch.
+   */
+  private closeBodyStream(
+    controller: ReadableStreamDefaultController<Uint8Array<ArrayBuffer>>
+  ): void {
+    if (this.bodyStreamClosed) {
+      return;
+    }
+    this.bodyStreamClosed = true;
+    if (controller.desiredSize == null) {
+      return;
+    }
+    try {
+      controller.close();
+    } catch {
+      // Closed by another path.
+    }
+  }
+
+  private errorBodyStream(
+    controller: ReadableStreamDefaultController<Uint8Array<ArrayBuffer>>,
+    error: unknown
+  ): void {
+    if (this.bodyStreamClosed) {
+      return;
+    }
+    this.bodyStreamClosed = true;
+    try {
+      controller.error(error);
+    } catch {
+      // Already closed or errored.
+    }
+  }
+
+  private enqueueBodyChunk(
+    controller: ReadableStreamDefaultController<Uint8Array<ArrayBuffer>>,
+    data: Uint8Array<ArrayBuffer>
+  ): void {
+    if (this.bodyStreamClosed || controller.desiredSize == null) {
+      return;
+    }
+    try {
+      controller.enqueue(data);
+    } catch {
+      // The stream left `readable` between the check and the enqueue — drop
+      // the chunk; throwing would error the stream behind the guard's back.
+    }
+  }
+
   // Originals have metadata=null and fall through to the native getter via super.
   // Clones carry a snapshot and stand alone.
 
@@ -199,38 +282,35 @@ export class FetchResponse extends ConcreteNativeResponse implements Response {
     const body = this[stateKey].body;
 
     if (body.stream == null) {
-      // This flag prevents enqueuing data after the stream is closed or canceled.
-      // Because it might be too late for the multithreaded native code to stop enqueuing data,
-      // we cannot simply rely on the native code to stop sending `didReceiveResponseData`.
-      let isControllerClosed = false;
-
+      // `bodyStreamClosed` prevents enqueuing/closing after the stream is
+      // closed, canceled, or aborted — native code may keep sending
+      // `didReceiveResponseData` past that point.
       body.stream = new ReadableStream(
         {
           start: (controller) => {
+            this.bodyStreamController = controller;
+
+            // Aborted before the first read — reject immediately.
+            if (this.abortReason !== undefined) {
+              this.bodyStreamClosed = true;
+              controller.error(this.abortReason);
+              return;
+            }
+
             if (body.streamingState === 'completed') {
               return;
             }
 
             this.addListener('didReceiveResponseData', (data: Uint8Array<ArrayBuffer>) => {
-              if (!isControllerClosed) {
-                controller.enqueue(data);
-              }
+              this.enqueueBodyChunk(controller, data);
             });
 
             this.addListener('didComplete', () => {
-              if (isControllerClosed) {
-                return;
-              }
-              isControllerClosed = true;
-              controller.close();
+              this.closeBodyStream(controller);
             });
 
             this.addListener('didFailWithError', (error: string) => {
-              if (isControllerClosed) {
-                return;
-              }
-              isControllerClosed = true;
-              controller.error(new Error(error));
+              this.errorBodyStream(controller, new Error(error));
             });
           },
 
@@ -239,25 +319,22 @@ export class FetchResponse extends ConcreteNativeResponse implements Response {
               const completedData = await this.startStreaming();
 
               if (completedData != null) {
-                if (!isControllerClosed) {
-                  controller.enqueue(completedData);
-                  controller.close();
-                  isControllerClosed = true;
-                }
-
+                this.enqueueBodyChunk(controller, completedData);
+                this.closeBodyStream(controller);
                 body.streamingState = 'completed';
               } else {
                 body.streamingState = 'started';
               }
             } else if (body.streamingState === 'completed') {
-              controller.close();
-              isControllerClosed = true;
+              this.closeBodyStream(controller);
             }
           },
 
           cancel: (reason) => {
+            // Flag first — the stream is already `closed` when this callback
+            // runs, so the guard must not go stale if cancelStreaming throws.
+            this.bodyStreamClosed = true;
             this.cancelStreaming(String(reason));
-            isControllerClosed = true;
           },
         },
         {

package/src/winter/fetch/__tests__/FetchResponse-test.ts

@@ -138,6 +138,96 @@ describe('FetchResponse', () => {
     await readPromise;
   });
 
+  describe('abort()', () => {
+    // abort() covers cancellation via an AbortSignal: fetch() routes it to a native
+    // request.cancel() that never reaches the JS controller, leaving the in-flight
+    // read hung (expo/expo#34804 / #33549 / #33553).
+
+    it('rejects the in-flight body read with an AbortError', async () => {
+      const response = makeResponse();
+      const reader = response.body!.getReader();
+      const pending = reader.read();
+
+      response.abort();
+
+      await expect(pending).rejects.toMatchObject({ name: 'AbortError' });
+    });
+
+    it('rejects a read started after abort with an AbortError', async () => {
+      const response = makeResponse();
+      const body = response.body!; // create the stream, then abort before reading
+      response.abort();
+
+      await expect(body.getReader().read()).rejects.toMatchObject({ name: 'AbortError' });
+    });
+
+    it('does not deliver or throw on native data that arrives after abort', async () => {
+      const response = makeResponse();
+      const reader = response.body!.getReader();
+      const pending = reader.read();
+
+      response.abort();
+      // The teardown race: native delivers one more data event after cancel.
+      const chunk = new TextEncoder().encode('late');
+      expect(() => (response as any).emit('didReceiveResponseData', chunk)).not.toThrow();
+      expect(() => (response as any).emit('didComplete')).not.toThrow();
+
+      await expect(pending).rejects.toMatchObject({ name: 'AbortError' });
+    });
+
+    it('preserves a provided abort reason', async () => {
+      const response = makeResponse();
+      const reader = response.body!.getReader();
+      const pending = reader.read();
+
+      const reason = new DOMException('user navigated away', 'AbortError');
+      response.abort(reason);
+
+      await expect(pending).rejects.toBe(reason);
+    });
+
+    it('is idempotent and safe to call twice', async () => {
+      const response = makeResponse();
+      response.body!.getReader();
+      response.abort();
+      expect(() => response.abort()).not.toThrow();
+    });
+  });
+
+  describe('internally errored stream (rejected pull)', () => {
+    // When pull() rejects, the streams implementation errors the stream internally
+    // without calling controller.error(), so the bodyStreamClosed guard goes stale.
+    // Native events landing after that used to throw on the errored stream.
+
+    it('surfaces the underlying error to the reader', async () => {
+      const response = makeResponse();
+
+      (response as any).startStreaming = async () => {
+        throw new Error('native module call failed');
+      };
+
+      const reader = response.body!.getReader();
+      await expect(reader.read()).rejects.toThrow('native module call failed');
+    });
+
+    it('does not throw on native events that arrive after pull() rejected', async () => {
+      const response = makeResponse();
+
+      (response as any).startStreaming = async () => {
+        throw new Error('native module call failed');
+      };
+
+      const reader = response.body!.getReader();
+      await expect(reader.read()).rejects.toThrow('native module call failed');
+
+      // The teardown race: native still delivers a chunk, then completion.
+      const chunk = new TextEncoder().encode('late');
+      expect(() => (response as any).emit('didReceiveResponseData', chunk)).not.toThrow();
+      expect(() => (response as any).emit('didComplete')).not.toThrow();
+      expect(() => (response as any).emit('didFailWithError', 'late error')).not.toThrow();
+    });
+  });
+
   describe('clone()', () => {
     it('returns a Response that exposes the same metadata', () => {
       const response = makeResponse();

package/src/winter/fetch/fetch.ts

@@ -75,9 +75,12 @@ export async function fetch(
   };
 
   if (signal && signal.aborted) {
-    throw new FetchError('The operation was aborted.');
+    throw new FetchError('The operation was aborted.', { cause: signal.reason });
   }
   abortSubscription = addAbortSignalListener(signal, () => {
+    // Abort the body stream before canceling the native request, so late
+    // native events can't reach an abandoned controller.
+    response.abort(signal?.reason);
     request.cancel();
   });
   try {