@depup/react-native 0.86.0-depup.49 → 0.87.0-depup.0

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/WritableMapBuffer.kt

@@ -84,6 +84,24 @@ internal class WritableMapBuffer : MapBuffer {
    */
   fun put(key: Int, value: MapBuffer): WritableMapBuffer = putInternal(key, value)
 
+  /**
+   * Adds an [IntArray] value for given key to the current MapBuffer.
+   *
+   * @param key entry key
+   * @param value entry value
+   * @throws IllegalArgumentException if key is out of [UShort] range
+   */
+  fun put(key: Int, value: IntArray): WritableMapBuffer = putInternal(key, value)
+
+  /**
+   * Adds a [DoubleArray] value for given key to the current MapBuffer.
+   *
+   * @param key entry key
+   * @param value entry value
+   * @throws IllegalArgumentException if key is out of [UShort] range
+   */
+  fun put(key: Int, value: DoubleArray): WritableMapBuffer = putInternal(key, value)
+
   private fun putInternal(key: Int, value: Any): WritableMapBuffer {
     require(key in KEY_RANGE) {
       "Only integers in [${UShort.MIN_VALUE};${UShort.MAX_VALUE}] range are allowed for keys."
@@ -126,6 +144,10 @@ internal class WritableMapBuffer : MapBuffer {
 
   override fun getMapBufferList(key: Int): List<MapBuffer> = verifyValue(key, values.get(key))
 
+  override fun getIntBuffer(key: Int): IntArray = verifyValue(key, values.get(key))
+
+  override fun getDoubleBuffer(key: Int): DoubleArray = verifyValue(key, values.get(key))
+
   /** Generalizes verification of the value types based on the requested type. */
   private inline fun <reified T> verifyValue(key: Int, value: Any?): T {
     require(value != null) { "Key not found: $key" }
@@ -143,6 +165,8 @@ internal class WritableMapBuffer : MapBuffer {
       is Double -> DataType.DOUBLE
       is String -> DataType.STRING
       is MapBuffer -> DataType.MAP
+      is IntArray -> DataType.INT_BUFFER
+      is DoubleArray -> DataType.DOUBLE_BUFFER
       else -> throw IllegalStateException("Key $key has value of unknown type: ${value.javaClass}")
     }
   }
@@ -176,6 +200,15 @@ internal class WritableMapBuffer : MapBuffer {
 
     override val mapBufferValue: MapBuffer
       get() = verifyValue(key, values.valueAt(index))
+
+    override val intBufferValue: IntArray
+      get() = verifyValue(key, values.valueAt(index))
+
+    override val doubleBufferValue: DoubleArray
+      get() = verifyValue(key, values.valueAt(index))
+
+    override val mapBufferListValue: List<MapBuffer>
+      get() = verifyValue(key, values.valueAt(index))
   }
 
   /*

package/ReactAndroid/src/main/java/com/facebook/react/defaults/DefaultNewArchitectureEntryPoint.kt

@@ -102,9 +102,7 @@ public object DefaultNewArchitectureEntryPoint {
       }
     }
 
-    privateFabricEnabled = fabricEnabled
     privateTurboModulesEnabled = turboModulesEnabled
-    privateConcurrentReactEnabled = fabricEnabled
     privateBridgelessEnabled = bridgelessEnabled
 
     DefaultSoLoader.maybeLoadSoLibrary()
@@ -114,15 +112,13 @@ public object DefaultNewArchitectureEntryPoint {
   internal fun loadWithFeatureFlags(featureFlags: ReactNativeFeatureFlagsProvider) {
     ReactNativeFeatureFlags.override(featureFlags)
 
-    privateFabricEnabled = featureFlags.enableFabricRenderer()
-    privateTurboModulesEnabled = featureFlags.useTurboModules()
-    privateConcurrentReactEnabled = featureFlags.enableFabricRenderer()
+    privateTurboModulesEnabled = true
     privateBridgelessEnabled = featureFlags.enableBridgelessArchitecture()
 
     val (isValid, errorMessage) =
         isConfigurationValid(
             privateTurboModulesEnabled,
-            privateFabricEnabled,
+            true,
             privateBridgelessEnabled,
         )
     if (!isValid) {
@@ -132,11 +128,9 @@ public object DefaultNewArchitectureEntryPoint {
     DefaultSoLoader.maybeLoadSoLibrary()
   }
 
-  private var privateFabricEnabled: Boolean = false
-
   @JvmStatic
   public val fabricEnabled: Boolean
-    get() = privateFabricEnabled
+    get() = true
 
   private var privateTurboModulesEnabled: Boolean = false
 
@@ -144,11 +138,9 @@ public object DefaultNewArchitectureEntryPoint {
   public val turboModulesEnabled: Boolean
     get() = privateTurboModulesEnabled
 
-  private var privateConcurrentReactEnabled: Boolean = false
-
   @JvmStatic
   public val concurrentReactEnabled: Boolean
-    get() = privateConcurrentReactEnabled
+    get() = true
 
   private var privateBridgelessEnabled: Boolean = false
 

package/ReactAndroid/src/main/java/com/facebook/react/defaults/DefaultReactActivityDelegate.kt

@@ -22,24 +22,28 @@ import com.facebook.react.ReactActivityDelegate
 public open class DefaultReactActivityDelegate(
     activity: ReactActivity,
     mainComponentName: String,
-    private val fabricEnabled: Boolean = false,
 ) : ReactActivityDelegate(activity, mainComponentName) {
 
   @Deprecated(
-      message =
-          "Creating DefaultReactActivityDelegate with both fabricEnabled and " +
-              "concurrentReactEnabled is deprecated. Please pass only one boolean value that will" +
-              " be used for both flags",
+      message = "Creating DefaultReactActivityDelegate with flags is deprecated.",
       level = DeprecationLevel.WARNING,
-      replaceWith =
-          ReplaceWith("DefaultReactActivityDelegate(activity, mainComponentName, fabricEnabled)"),
+      replaceWith = ReplaceWith("DefaultReactActivityDelegate(activity, mainComponentName)"),
   )
   public constructor(
       activity: ReactActivity,
       mainComponentName: String,
-      fabricEnabled: Boolean,
+      @Suppress("UNUSED_PARAMETER") fabricEnabled: Boolean,
       @Suppress("UNUSED_PARAMETER") concurrentReactEnabled: Boolean,
-  ) : this(activity, mainComponentName, fabricEnabled)
+  ) : this(activity, mainComponentName)
 
-  override fun isFabricEnabled(): Boolean = fabricEnabled
+  @Deprecated(
+      message = "Creating DefaultReactActivityDelegate with flags is deprecated.",
+      level = DeprecationLevel.WARNING,
+      replaceWith = ReplaceWith("DefaultReactActivityDelegate(activity, mainComponentName)"),
+  )
+  public constructor(
+      activity: ReactActivity,
+      mainComponentName: String,
+      @Suppress("UNUSED_PARAMETER") fabricEnabled: Boolean,
+  ) : this(activity, mainComponentName)
 }

package/ReactAndroid/src/main/java/com/facebook/react/defaults/DefaultReactNativeHost.kt

@@ -54,7 +54,7 @@ protected constructor(
           DefaultComponentsRegistry.register(componentFactory)
 
           val viewManagerRegistry =
-              if (lazyViewManagersEnabled) {
+              if (getLazyViewManagersEnabled()) {
                 ViewManagerRegistry(
                     object : ViewManagerResolver {
                       override fun getViewManager(viewManagerName: String) =
@@ -120,12 +120,12 @@ protected constructor(
     val concreteJSRuntimeFactory = jsRuntimeFactory ?: HermesInstance()
     return DefaultReactHost.getDefaultReactHost(
         context,
-        packages,
-        jsMainModuleName,
-        bundleAssetName ?: "index.android.bundle",
-        jsBundleFile,
+        getPackages(),
+        getJSMainModuleName(),
+        getBundleAssetName() ?: "index.android.bundle",
+        getJSBundleFile(),
         concreteJSRuntimeFactory,
-        useDeveloperSupport,
+        getUseDeveloperSupport(),
     )
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/BundleDownloader.kt

@@ -26,7 +26,6 @@ import okhttp3.Headers
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.Response
-import okio.Buffer
 import okio.BufferedSource
 import okio.Okio
 import org.json.JSONException
@@ -121,11 +120,7 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
 
                   val url = resp.request().url().toString()
                   // Make sure the result is a multipart response and parse the boundary.
-                  var contentType = resp.header("content-type")
-                  if (contentType == null) {
-                    // fallback to empty string for nullability
-                    contentType = ""
-                  }
+                  val contentType = resp.header("content-type") ?: ""
                   val regex = Pattern.compile("multipart/mixed;.*boundary=\"([^\"]+)\"")
                   val match = regex.matcher(contentType)
                   if (contentType.isNotEmpty() && match.find()) {
@@ -135,18 +130,28 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
                     // In case the server doesn't support multipart/mixed responses, fallback to
                     // normal
                     // download.
-                    resp.body().use { body ->
-                      if (body != null) {
+                    val body = resp.body()
+                    if (body != null) {
+                      body.use {
                         processBundleResult(
                             url,
                             resp.code(),
                             resp.headers(),
-                            body.source(),
+                            it.source(),
                             outputFile,
                             bundleInfo,
                             callback,
                         )
                       }
+                    } else {
+                      callback.onFailure(
+                          makeGeneric(
+                              url,
+                              "Development server response body was empty.",
+                              "URL: $url",
+                              null,
+                          )
+                      )
                     }
                   }
                 }
@@ -164,7 +169,8 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
       bundleInfo: BundleInfo?,
       callback: DevBundleDownloadListener,
   ) {
-    if (response.body() == null) {
+    val responseBody = response.body()
+    if (responseBody == null) {
       callback.onFailure(
           DebugServerException(
               ("""
@@ -181,7 +187,8 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
       )
       return
     }
-    val source = checkNotNull(response.body()?.source())
+
+    val source = responseBody.source()
     val bodyReader = MultipartStreamReader(source, boundary)
     val completed =
         bodyReader.readAllParts(
@@ -189,19 +196,16 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
               @Throws(IOException::class)
               override fun onChunkComplete(
                   headers: Map<String, String>,
-                  body: Buffer,
+                  body: BufferedSource,
                   isLastChunk: Boolean,
               ) {
                 // This will get executed for every chunk of the multipart response. The last chunk
                 // (isLastChunk = true) will be the JS bundle, the other ones will be progress
-                // events
-                // encoded as JSON.
+                // events encoded as JSON.
                 if (isLastChunk) {
                   // The http status code for each separate chunk is in the X-Http-Status header.
-                  var status = response.code()
-                  if (headers.containsKey("X-Http-Status")) {
-                    status = headers.getOrDefault("X-Http-Status", "0").toInt()
-                  }
+                  val status = headers["X-Http-Status"]?.toIntOrNull() ?: response.code()
+
                   processBundleResult(
                       url,
                       status,
@@ -211,34 +215,26 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
                       bundleInfo,
                       callback,
                   )
-                } else {
-                  if (
-                      !headers.containsKey("Content-Type") ||
-                          headers["Content-Type"] != "application/json"
-                  ) {
-                    return
-                  }
+                  return
+                }
 
-                  try {
-                    val progress = JSONObject(body.readUtf8())
-                    val status =
-                        if (progress.has("status")) progress.getString("status") else "Bundling"
-                    var done: Int? = null
-                    if (progress.has("done")) {
-                      done = progress.getInt("done")
-                    }
-                    var total: Int? = null
-                    if (progress.has("total")) {
-                      total = progress.getInt("total")
-                    }
-                    var percent: Int? = null
-                    if (progress.has("percent")) {
-                      percent = progress.getInt("percent")
-                    }
-                    callback.onProgress(status, done, total, percent)
-                  } catch (e: JSONException) {
-                    FLog.e(ReactConstants.TAG, "Error parsing progress JSON. $e")
-                  }
+                val contentType = headers["Content-Type"] ?: return
+                if (!isJsonContentType(contentType)) {
+                  return
+                }
+
+                try {
+                  // Body is already bounded to this part; safe to read fully.
+                  val progress = JSONObject(body.readUtf8())
+                  val status =
+                      if (progress.has("status")) progress.getString("status") else "Bundling"
+                  val done: Int? = if (progress.has("done")) progress.getInt("done") else null
+                  val total: Int? = if (progress.has("total")) progress.getInt("total") else null
+                  val percent: Int? =
+                      if (progress.has("percent")) progress.getInt("percent") else null
+                  callback.onProgress(status, done, total, percent)
+                } catch (e: JSONException) {
+                  FLog.e(ReactConstants.TAG, "Error parsing progress JSON.", e)
                 }
               }
 
@@ -247,7 +243,8 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
                   loaded: Long,
                   total: Long,
               ) {
-                if ("application/javascript" == headers["Content-Type"]) {
+                val contentType = headers["Content-Type"] ?: return
+                if (isJavaScriptContentType(contentType)) {
                   callback.onProgress(
                       "Downloading",
                       (loaded / 1024).toInt(),
@@ -258,6 +255,7 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
               }
             }
         )
+
     if (!completed) {
       callback.onFailure(
           DebugServerException(
@@ -331,7 +329,7 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
 
     @Throws(IOException::class)
     private fun storePlainJSInFile(body: BufferedSource, outputFile: File): Boolean {
-      Okio.sink(outputFile).use { it -> body.readAll(it) }
+      Okio.sink(outputFile).use { sink -> body.readAll(sink) }
       return true
     }
 
@@ -348,5 +346,10 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
         }
       }
     }
+
+    private fun isJsonContentType(value: String): Boolean = value.startsWith("application/json")
+
+    private fun isJavaScriptContentType(value: String): Boolean =
+        value.startsWith("application/javascript")
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevServerHelper.kt

@@ -78,10 +78,6 @@ public open class DevServerHelper(
     public fun customCommandHandlers(): Map<String, RequestHandler>?
   }
 
-  public val websocketProxyURL: String
-    get() =
-        "${DevSupportHttpClient.wsScheme(packagerConnectionSettings.debugServerHost)}://${packagerConnectionSettings.debugServerHost}/debugger-proxy?role=client"
-
   private enum class BundleType(val typeID: String) {
     BUNDLE("bundle"),
     MAP("map"),

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevSupportManagerFactory.kt

@@ -48,15 +48,15 @@ public interface DevSupportManagerFactory {
   public fun create(
       applicationContext: Context,
       reactInstanceManagerHelper: ReactInstanceDevHelper,
-      packagerPathForJSBundleName: String?,
-      enableOnCreate: Boolean,
-      redBoxHandler: RedBoxHandler?,
-      devBundleDownloadListener: DevBundleDownloadListener?,
-      minNumShakes: Int,
-      customPackagerCommandHandlers: Map<String, RequestHandler>?,
-      surfaceDelegateFactory: SurfaceDelegateFactory?,
-      devLoadingViewManager: DevLoadingViewManager?,
-      pausedInDebuggerOverlayManager: PausedInDebuggerOverlayManager?,
-      useDevSupport: Boolean,
+      packagerPathForJSBundleName: String? = null,
+      enableOnCreate: Boolean = true,
+      redBoxHandler: RedBoxHandler? = null,
+      devBundleDownloadListener: DevBundleDownloadListener? = null,
+      minNumShakes: Int = 2,
+      customPackagerCommandHandlers: Map<String, RequestHandler>? = null,
+      surfaceDelegateFactory: SurfaceDelegateFactory? = null,
+      devLoadingViewManager: DevLoadingViewManager? = null,
+      pausedInDebuggerOverlayManager: PausedInDebuggerOverlayManager? = null,
+      useDevSupport: Boolean = true,
   ): DevSupportManager
 }

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/LocalNetworkPermissionUtil.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.devsupport
+
+import android.app.Activity
+import android.content.pm.PackageManager
+import android.os.Build
+import com.facebook.react.common.build.ReactBuildConfig
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.util.AndroidVersion
+
+/**
+ * Debug-only helper to request the runtime `ACCESS_LOCAL_NETWORK` permission needed to reach Metro
+ * on Android 17 (SDK 37) devices, which gate local-network addresses (the emulator's `10.0.2.2`
+ * alias, a device's Wi-Fi/LAN IP). Requested only in debuggable builds, and always (like iOS),
+ * since the dev-server host can change at runtime (e.g. switching from `adb reverse` to a LAN IP).
+ */
+internal object LocalNetworkPermissionUtil {
+  private const val PERMISSION = "android.permission.ACCESS_LOCAL_NETWORK"
+  private const val PERMISSION_REQUEST_CODE = 1
+
+  /**
+   * Invokes [onResolved] once it is safe to connect to Metro: immediately when no permission is
+   * needed, or after the user answers the `ACCESS_LOCAL_NETWORK` prompt otherwise.
+   */
+  @JvmStatic
+  fun requestLocalNetworkAccessIfNeeded(activity: Activity, onResolved: Runnable) {
+    if (activity is PermissionAwareActivity && needsLocalNetworkPrompt(activity)) {
+      activity.requestPermissions(arrayOf(PERMISSION), PERMISSION_REQUEST_CODE) { _, _, _ ->
+        onResolved.run()
+        true
+      }
+    } else {
+      onResolved.run()
+    }
+  }
+
+  /** Whether the `ACCESS_LOCAL_NETWORK` prompt must be shown before reaching the dev server. */
+  private fun needsLocalNetworkPrompt(activity: Activity): Boolean {
+    if (!ReactBuildConfig.DEBUG) return false // dev-server only; never prompt in release builds
+    if (Build.VERSION.SDK_INT < AndroidVersion.VERSION_CODE_CINNAMON_BUN) return false
+    return activity.checkSelfPermission(PERMISSION) != PackageManager.PERMISSION_GRANTED
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/MultipartStreamReader.kt

@@ -10,10 +10,14 @@
 package com.facebook.react.devsupport
 
 import java.io.IOException
+import java.util.TreeMap
 import kotlin.math.max
 import okio.Buffer
 import okio.BufferedSource
 import okio.ByteString
+import okio.Okio
+import okio.Source
+import okio.Timeout
 
 /** Utility class to parse the body of a response of type multipart/mixed. */
 internal class MultipartStreamReader(
@@ -25,7 +29,7 @@ internal class MultipartStreamReader(
   interface ChunkListener {
     /** Invoked when a chunk of a multipart response is fully downloaded. */
     @Throws(IOException::class)
-    fun onChunkComplete(headers: Map<String, String>, body: Buffer, isLastChunk: Boolean)
+    fun onChunkComplete(headers: Map<String, String>, body: BufferedSource, isLastChunk: Boolean)
 
     /** Invoked as bytes of the current chunk are read. */
     @Throws(IOException::class)
@@ -44,12 +48,16 @@ internal class MultipartStreamReader(
     val closeDelimiter: ByteString = ByteString.encodeUtf8("$CRLF--$boundary--$CRLF")
     val headersDelimiter: ByteString = ByteString.encodeUtf8(CRLF + CRLF)
 
-    val bufferLen = 4 * 1024
+    // Buffer size for reading from network. Increased from 4KB to 16KB for better I/O
+    // throughput and fewer syscalls. For a 2MB bundle: ~128 reads instead of ~512.
+    // Memory impact is negligible (12KB increase) while I/O overhead is significantly reduced.
+    val bufferLen = 16 * 1024
     var chunkStart: Long = 0
     var bytesSeen: Long = 0
     val content = Buffer()
+
     var currentHeaders: Map<String, String>? = null
-    var currentHeadersLength: Long = 0
+    var currentBodyStartIndexInContent: Long = -1
 
     while (true) {
       var isCloseDelimiter = false
@@ -58,6 +66,7 @@ internal class MultipartStreamReader(
       // to allow for the edge case when the delimiter is cut by read call.
       val searchStart =
           max((bytesSeen - closeDelimiter.size()).toDouble(), chunkStart.toDouble()).toLong()
+
       var indexOfDelimiter = content.indexOf(delimiter, searchStart)
       if (indexOfDelimiter == -1L) {
         isCloseDelimiter = true
@@ -68,16 +77,17 @@ internal class MultipartStreamReader(
         bytesSeen = content.size()
 
         if (currentHeaders == null) {
-          val indexOfHeaders = content.indexOf(headersDelimiter, searchStart)
-          if (indexOfHeaders >= 0) {
-            source.read(content, indexOfHeaders)
+          val indexOfHeadersDelimiter = content.indexOf(headersDelimiter, searchStart)
+          if (indexOfHeadersDelimiter >= 0) {
             val headers = Buffer()
-            content.copyTo(headers, searchStart, indexOfHeaders - searchStart)
-            currentHeadersLength = headers.size() + headersDelimiter.size()
+            content.copyTo(headers, searchStart, indexOfHeadersDelimiter - searchStart)
             currentHeaders = parseHeaders(headers)
+            currentBodyStartIndexInContent =
+                indexOfHeadersDelimiter + headersDelimiter.size().toLong()
           }
         } else {
-          emitProgress(currentHeaders, content.size() - currentHeadersLength, false, listener)
+          val loaded = max(0L, content.size() - currentBodyStartIndexInContent)
+          emitProgress(currentHeaders, loaded, false, listener)
         }
 
         val bytesRead = source.read(content, bufferLen.toLong())
@@ -92,26 +102,30 @@ internal class MultipartStreamReader(
 
       // Ignore preamble
       if (chunkStart > 0) {
-        val chunk = Buffer()
+        if (currentHeaders != null && currentBodyStartIndexInContent >= 0) {
+          val loadedFinal = max(0L, chunkEnd - currentBodyStartIndexInContent)
+          emitProgress(currentHeaders, loadedFinal, true, listener)
+        }
         content.skip(chunkStart)
-        content.read(chunk, length)
-        emitProgress(currentHeaders, chunk.size() - currentHeadersLength, true, listener)
-        emitChunk(chunk, isCloseDelimiter, listener)
+        emitChunk(content, length, isCloseDelimiter, listener)
+
         currentHeaders = null
-        currentHeadersLength = 0
+        currentBodyStartIndexInContent = -1
       } else {
         content.skip(chunkEnd)
       }
       if (isCloseDelimiter) {
         return true
       }
+
       chunkStart = delimiter.size().toLong()
       bytesSeen = chunkStart
     }
   }
 
   private fun parseHeaders(data: Buffer): Map<String, String> {
-    val headers: MutableMap<String, String> = mutableMapOf()
+    // Header names are case-insensitive
+    val headers: MutableMap<String, String> = TreeMap(String.CASE_INSENSITIVE_ORDER)
     val text = data.readUtf8()
     val lines = text.split(CRLF.toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
     for (line in lines) {
@@ -126,20 +140,81 @@ internal class MultipartStreamReader(
     return headers
   }
 
+  /**
+   * Emits a chunk to the listener. The `body` passed to the listener is bounded to the chunk body
+   * bytes, so the listener cannot accidentally read into the next boundary.
+   *
+   * Also drains any unread body bytes after the callback to keep parsing in sync.
+   */
   @Throws(IOException::class)
-  private fun emitChunk(chunk: Buffer, done: Boolean, listener: ChunkListener) {
+  private fun emitChunk(
+      content: Buffer,
+      chunkLength: Long,
+      done: Boolean,
+      listener: ChunkListener,
+  ) {
     val marker: ByteString = ByteString.encodeUtf8(CRLF + CRLF)
-    val indexOfMarker = chunk.indexOf(marker)
-    if (indexOfMarker == -1L) {
-      listener.onChunkComplete(emptyMap(), chunk, done)
-    } else {
-      val headers = Buffer()
-      val body = Buffer()
-      chunk.read(headers, indexOfMarker)
-      chunk.skip(marker.size().toLong())
-      chunk.readAll(body)
-      listener.onChunkComplete(parseHeaders(headers), body, done)
+    val indexOfMarker = content.indexOf(marker, 0)
+
+    if (indexOfMarker == -1L || indexOfMarker >= chunkLength) {
+      // No headers marker found inside the chunk. Treat the entire chunk as body.
+      val bodyLength = chunkLength
+      val body = Okio.buffer(FixedLengthSource(content, bodyLength))
+      try {
+        listener.onChunkComplete(emptyMap(), body, done)
+      } finally {
+        drainFully(body)
+      }
+      return
     }
+
+    // Headers exist.
+    val headersBuf = Buffer()
+    content.read(headersBuf, indexOfMarker)
+    content.skip(marker.size().toLong())
+    val headers = parseHeaders(headersBuf)
+
+    val maxBodyLength = chunkLength - indexOfMarker - marker.size().toLong()
+    val body = Okio.buffer(FixedLengthSource(content, maxBodyLength))
+    try {
+      listener.onChunkComplete(headers, body, done)
+    } finally {
+      drainFully(body)
+    }
+  }
+
+  private fun drainFully(body: BufferedSource) {
+    // Drain remaining bytes from this part body (if listener didn't).
+    // Use small reusable buffer to avoid unbounded memory.
+    val tmp = Buffer()
+    try {
+      while (true) {
+        val r = body.read(tmp, 8 * 1024L)
+        if (r == -1L) break
+        tmp.clear()
+      }
+    } catch (_: IOException) {
+      // Best-effort drain; parsing will likely fail upstream anyway.
+    }
+  }
+
+  private class FixedLengthSource(
+      private val upstream: Buffer,
+      private var remaining: Long,
+  ) : Source {
+    override fun read(sink: Buffer, byteCount: Long): Long {
+      if (byteCount == 0L) return 0L
+      if (remaining == 0L) return -1L
+      val toRead = minOf(byteCount, remaining)
+      val read = upstream.read(sink, toRead)
+      if (read == -1L) return -1L
+      remaining -= read
+      return read
+    }
+
+    override fun timeout(): Timeout = Timeout.NONE
+
+    override fun close() = Unit
   }
 
   @Throws(IOException::class)