expo-modules-core 58.0.1 → 58.0.2

package/CHANGELOG.md

@@ -10,6 +10,16 @@
 
 ### 💡 Others
 
+## 58.0.2 — 2026-09-15
+
+### 🛠 Breaking changes
+
+- [Android] Compile `expo-module-gradle-plugin` against Android Gradle Plugin 9.2.1 and drop the Android Gradle Plugin 8 compatibility code. ([#50114](https://github.com/expo/expo/pull/50114) by [@lukmccall](https://github.com/lukmccall))
+
+### 🐛 Bug fixes
+
+- [Android] Fixed native-backed `ArrayBuffer`s and `NativeArrayBuffer`s being copied instead of shared when passed back from JS on Hermes V1. ([#50132](https://github.com/expo/expo/pull/50132) by [@lukmccall](https://github.com/lukmccall))
+
 ## 58.0.1 — 2026-09-14
 
 ### 🎉 New features
@@ -34,6 +44,7 @@
 
 ### 🎉 New features
 
+- [macOS] Added `UIColor`, `UIGestureRecognizer` and `UITextContentType` to the AppKit compatibility aliases in `Platform.swift`. ([#50110](https://github.com/expo/expo/pull/50110) by [@gabrieldonadel](https://github.com/gabrieldonadel))
 - [Android] Added a `loadImageForManipulationFromURL` overload to `ImageLoaderInterface` that decodes the image within the given `maxWidth`/`maxHeight` bounds. ([#47877](https://github.com/expo/expo/pull/47877) by [@jiunshinn](https://github.com/jiunshinn))
 - Add `useReleasingSharedObjectWithLifecycle` hook. ([#46494](https://github.com/expo/expo/pull/46494) by [@behenate](https://github.com/behenate))
 - Added `ArrayBuffer` as the preferred safe native module argument and return type, and deprecated `NativeArrayBuffer` in favor of it. ([#47106](https://github.com/expo/expo/pull/47106) by [@barthap](https://github.com/barthap))

package/android/CMakeLists.txt

@@ -7,11 +7,21 @@ project(expo-modules-core)
 include(${CMAKE_SOURCE_DIR}/cmake/variables.cmake)
 include(${CMAKE_SOURCE_DIR}/cmake/common.cmake)
 
-# defines expo-modules-jsi target
-include(${CMAKE_SOURCE_DIR}/cmake/jsi.cmake)
+# When prebuilt artifacts are shipped in the package, imports expo-modules-jsi / expo-modules-core
+# as IMPORTED targets (and sets EXPO_JSI_PREBUILT / EXPO_CORE_PREBUILT) so they are not recompiled.
+if (EXPO_PREBUILT_NATIVE_LIBS_DIR)
+  include(${CMAKE_SOURCE_DIR}/cmake/prebuilt.cmake)
+endif ()
+
+# defines expo-modules-jsi target, unless it was imported from a prebuilt artifact above
+if (NOT EXPO_JSI_PREBUILT)
+  include(${CMAKE_SOURCE_DIR}/cmake/jsi.cmake)
+endif ()
 
-# defines expo-modules-core target
-include(${CMAKE_SOURCE_DIR}/cmake/main.cmake)
+# defines expo-modules-core target, unless it was imported from a prebuilt artifact above
+if (NOT EXPO_CORE_PREBUILT)
+  include(${CMAKE_SOURCE_DIR}/cmake/main.cmake)
+endif ()
 
 # defines expo-modules-worklets target (worklets integration), only when react-native-worklets is installed
 if (REACT_NATIVE_WORKLETS_DIR)

package/android/build.gradle

@@ -1,6 +1,18 @@
-import groovy.json.JsonSlurper
 import expo.modules.plugin.gradle.ExpoModuleExtension
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import org.apache.commons.compress.archivers.tar.TarArchiveEntry
+import org.apache.commons.compress.archivers.tar.TarArchiveInputStream
+import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.tukaani.xz.LZMA2Options
+import org.tukaani.xz.XZInputStream
+import org.tukaani.xz.XZOutputStream
+
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+import java.time.Instant
+import java.util.regex.Matcher
 
 buildscript {
   // List of features that are required by linked modules
@@ -16,6 +28,8 @@ buildscript {
       classpath("org.jetbrains.kotlin.plugin.compose:org.jetbrains.kotlin.plugin.compose.gradle.plugin:${kotlinVersion}")
     }
 
+    classpath "org.tukaani:xz:1.12"
+    classpath "org.apache.commons:commons-compress:1.28.0"
   }
 }
 
@@ -27,7 +41,7 @@ if (shouldIncludeCompose) {
 }
 
 group = 'host.exp.exponent'
-version = '58.0.1'
+version = '58.0.2'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -78,7 +92,7 @@ if (workletsProject != null) {
 
 def reactNativeWorkletsRootDir = workletsProject?.projectDir?.parentFile
 
-def expoModulesV2Version = "0.1.2"
+def expoModulesV2Version = "0.1.5"
 
 configurations {
   // Artifact-only: the C++ sources, not something to put on any classpath.
@@ -99,6 +113,36 @@ tasks.matching {
   it.dependsOn(unpackExpoModulesV2Cpp)
 }
 
+def reactNativeVersionString = expoModuleExtension.reactNativeVersion.toString()
+
+def prebuiltNativeLibsDir = project.file("prebuilt")
+def prebuiltNativeLibsArchive = project.file("prebuilt/native-libs.tar.xz")
+def prebuiltMetadataFile = project.file("prebuilt/metadata.json")
+
+def decompressedNativeLibsDir = layout.buildDirectory.dir("expo-prebuilt-natives").get().asFile
+
+def prebuiltVariants = ["debug", "release"]
+
+def isPrebuiltCachingRun = gradle.startParameter.taskNames.any { it.contains("cachePrebuiltNativeLibs") }
+
+def isPrebuiltUsable = {
+  if (!prebuiltMetadataFile.exists() || !prebuiltNativeLibsArchive.exists()) {
+    return false
+  }
+  def metadata = new JsonSlurper().parseText(prebuiltMetadataFile.text)
+  if (metadata.libraryVersion != version) {
+    logger.warn("[expo-modules-core] Ignoring prebuilt libs: built for v${metadata.libraryVersion}, package is v${version} - building from source")
+    return false
+  }
+  if (metadata.reactNativeVersion != reactNativeVersionString) {
+    logger.warn("[expo-modules-core] Ignoring prebuilt libs: built for RN ${metadata.reactNativeVersion}, installed RN ${reactNativeVersionString} - building from source")
+    return false
+  }
+  return true
+}
+
+def usePrebuiltNativeLibs = !isPrebuiltCachingRun && !isTests && isPrebuiltUsable()
+
 expoModule {
   canBePublished false
 }
@@ -115,7 +159,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "58.0.1"
+    versionName "58.0.2"
     buildConfigField "String", "EXPO_MODULES_CORE_VERSION", "\"${versionName}\""
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true"
 
@@ -137,6 +181,10 @@ android {
           cppArguments += "-DREACT_NATIVE_WORKLETS_DIR=${reactNativeWorkletsRootDir.absolutePath}"
         }
 
+        if (usePrebuiltNativeLibs) {
+          cppArguments += "-DEXPO_PREBUILT_NATIVE_LIBS_DIR=${decompressedNativeLibsDir.absolutePath}"
+        }
+
         abiFilters(*reactNativeArchitectures())
         arguments(*cppArguments)
       }
@@ -210,6 +258,14 @@ android {
         }
       }
     }
+
+    // Package the decompressed prebuilt .so into each variant. The layout `<variant>/<abi>/lib*.so`
+    // matches what AGP expects from a jniLibs source set.
+    if (usePrebuiltNativeLibs) {
+      prebuiltVariants.each { variant ->
+        getByName(variant).jniLibs.srcDir(new File(decompressedNativeLibsDir, variant))
+      }
+    }
   }
 
   testOptions {
@@ -320,10 +376,10 @@ def generateStubPCHTask = tasks.register("generateStubPCH") {
           def stubHeaderPath = stubHeader.absolutePath.replace('\\', '/')
 
           def cmd = entry.command
-            // Replace the forced-include path: `-Xclang -include -Xclang <path>/cmake_pch.hxx`
-            .replaceAll(/-Xclang -include -Xclang [^\s]+cmake_pch\.hxx(?=\s)/, java.util.regex.Matcher.quoteReplacement("-Xclang -include -Xclang ${stubHeaderPath}"))
-            // Replace the source file operand: `<path>/cmake_pch.hxx.cxx`
-            .replaceAll(/[^\s]+cmake_pch\.hxx\.cxx/, java.util.regex.Matcher.quoteReplacement(stubHeaderPath))
+          // Replace the forced-include path: `-Xclang -include -Xclang <path>/cmake_pch.hxx`
+            .replaceAll(/-Xclang -include -Xclang [^\s]+cmake_pch\.hxx(?=\s)/, Matcher.quoteReplacement("-Xclang -include -Xclang ${stubHeaderPath}"))
+          // Replace the source file operand: `<path>/cmake_pch.hxx.cxx`
+            .replaceAll(/[^\s]+cmake_pch\.hxx\.cxx/, Matcher.quoteReplacement(stubHeaderPath))
 
           def process = new ProcessBuilder(cmd.split(" ").toList())
             .directory(new File(entry.directory))
@@ -344,3 +400,206 @@ def generateStubPCHTask = tasks.register("generateStubPCH") {
 tasks.register("prepareKotlinBuildScriptModel") {
   dependsOn(generateStubPCHTask)
 }
+
+def prebuiltNativeLibNames = ["libexpo-modules-core.so", "libexpo-modules-jsi.so"]
+
+// Helpers for the cachePrebuiltNativeLibs task. They are `static` so the task action can call them
+// without capturing the build script, which keeps the task configuration-cache compatible.
+class PrebuiltNativeLibs {
+  /**
+   * Returns host tag based on the OS name.
+   */
+  private static String hostTag() {
+    def osName = System.getProperty("os.name").toLowerCase()
+    if (osName.contains("mac")) {
+      return "darwin-x86_64"
+    }
+
+    if (osName.contains("win")) {
+      return "windows-x86_64"
+    }
+
+    return "linux-x86_64"
+  }
+
+  private static void strippedLib(File stripBinary, File source, File dest) {
+    def proc = new ProcessBuilder(
+      stripBinary.absolutePath,
+      "--strip-all",
+      source.absolutePath,
+      "-o",
+      dest.absolutePath
+    )
+      .redirectErrorStream(true)
+      .start()
+
+    if (proc.waitFor() != 0) {
+      throw new GradleException("[expo-modules-core] llvm-strip failed for ${source}: ${proc.inputStream.text}")
+    }
+  }
+
+  /**
+   * Locate the NDK's `llvm-strip`, or null when the NDK/binary can't be found.
+   */
+  static File findLlvmStrip(File ndkDir) {
+    if (ndkDir == null || !ndkDir.exists()) {
+      return null
+    }
+    def hostTag = hostTag()
+    def strip = new File(ndkDir, "toolchains/llvm/prebuilt/${hostTag}/bin/llvm-strip")
+    return strip.exists() ? strip : null
+  }
+
+  /**
+   * Copy each of `soNames` from `objDir/<abi>/` into `stagingVariantDir/<abi>/`, stripping debug
+   * symbols. Returns the set of ABIs that were staged.
+   */
+  static Set<String> stageStrippedLibs(File objDir, List<String> soNames, File stagingVariantDir, File stripBinary) {
+    def abis = new TreeSet<String>()
+    objDir
+      .listFiles({ it.isDirectory() } as FileFilter)
+      ?.each { abiDir ->
+        soNames.each { soName ->
+          def source = new File(abiDir, soName)
+          if (!source.exists()) {
+            return
+          }
+
+          def dest = new File(stagingVariantDir, "${abiDir.name}/${soName}")
+          dest.parentFile.mkdirs()
+
+          if (stripBinary != null) {
+            strippedLib(stripBinary, source, dest)
+          } else {
+            Files.copy(source.toPath(), dest.toPath(), StandardCopyOption.REPLACE_EXISTING)
+          }
+
+          abis << abiDir.name
+        }
+      }
+    return abis
+  }
+
+  /**
+   * Bundle every file under `stagingDir` into a single solid tar.xz
+   */
+  static void bundleToTarXz(File stagingDir, File archive) {
+    archive.parentFile.mkdirs()
+    def stagingPath = stagingDir.toPath()
+
+    def files = []
+    stagingDir.eachFileRecurse {
+      if (it.isFile()) {
+        files << it
+      }
+    }
+    files.sort { it.absolutePath }
+
+    new TarArchiveOutputStream(
+      new XZOutputStream(archive.newOutputStream(), new LZMA2Options(9))
+    ).withCloseable { tar ->
+      files.each { file ->
+        def archiveEntry = new TarArchiveEntry(file, stagingPath.relativize(file.toPath()).toString())
+        tar.putArchiveEntry(archiveEntry)
+        Files.copy(file.toPath(), tar)
+        tar.closeArchiveEntry()
+      }
+    }
+  }
+}
+
+def stripBinary = PrebuiltNativeLibs.findLlvmStrip(android.ndkDirectory)
+def libraryVersion = version.toString()
+def cacheStagingDir = layout.buildDirectory.dir("tmp/cache-prebuilt-natives").get().asFile
+def variantDescriptors = prebuiltVariants.collect { variant ->
+  def variantCap = variant.capitalize()
+  def libsDir = layout.buildDirectory.dir("intermediates/merged_native_libs/${variant}/merge${variantCap}NativeLibs/out/lib").get().asFile
+  def outDir = layout.buildDirectory.dir("tmp/cache-prebuilt-natives/${variant}").get().asFile
+  [
+    name     : variant,
+    mergeTask: "merge${variantCap}NativeLibs",
+    libsDir  : libsDir,
+    outDir   : outDir,
+  ]
+}
+
+tasks.register("cachePrebuiltNativeLibs") {
+  group = "prebuilt natives"
+  description = "Build expo-modules-core from source (debug + release), strip and cache the shippable .so files into prebuilt/"
+  dependsOn(variantDescriptors.collect { it.mergeTask })
+
+  doLast {
+    if (stripBinary == null) {
+      logger.warn("[expo-modules-core] NDK llvm-strip not found - .so files will be cached unstripped")
+    }
+
+    if (prebuiltNativeLibsDir.exists()) {
+      prebuiltNativeLibsDir.deleteDir()
+    }
+
+    if (cacheStagingDir.exists()) {
+      cacheStagingDir.deleteDir()
+    }
+
+    def allAbis = new TreeSet<String>()
+    variantDescriptors.each { vd ->
+      logger.lifecycle("[expo-modules-core] Caching ${vd.name} from ${vd.libsDir}")
+      allAbis.addAll(PrebuiltNativeLibs.stageStrippedLibs(vd.libsDir, prebuiltNativeLibNames, vd.outDir, stripBinary))
+    }
+    if (allAbis.isEmpty()) {
+      throw new GradleException("[expo-modules-core] No ${prebuiltNativeLibNames} were cached")
+    }
+
+    PrebuiltNativeLibs.bundleToTarXz(cacheStagingDir, prebuiltNativeLibsArchive)
+    cacheStagingDir.deleteDir()
+
+    prebuiltMetadataFile.text = JsonOutput.prettyPrint(JsonOutput.toJson([
+      libraryVersion    : libraryVersion,
+      reactNativeVersion: reactNativeVersionString,
+      variants          : variantDescriptors.collect { it.name },
+      abis              : allAbis as List,
+      soFiles           : prebuiltNativeLibNames as List,
+      stripped          : stripBinary != null,
+      createdAt          : Instant.now().toString(),
+    ])) + "\n"
+
+    def archiveSizeMb = prebuiltNativeLibsArchive.length() / (1024 * 1024)
+    logger.lifecycle(
+      "[expo-modules-core] Create ${prebuiltNativeLibNames.join(", ")} for ${allAbis.size()} ABIs " +
+        "(${allAbis.join(", ")}) x ${variantDescriptors.size()} variants into " +
+        "${prebuiltNativeLibsArchive.name} (~${archiveSizeMb}MB, stripped, solid tar.xz)"
+    )
+  }
+}
+
+// Unpacks the shipped solid `prebuilt/native-libs.tar.xz` into the build dir so CMake can import the
+// libs and AGP can package them via the jniLibs source sets
+if (usePrebuiltNativeLibs) {
+  def archiveFile = prebuiltNativeLibsArchive
+  def outputDir = decompressedNativeLibsDir
+  def decompressPrebuiltNativeLibs = tasks.register("decompressPrebuiltNativeLibs") {
+    description = "Unpack the shipped native-libs.tar.xz into the build dir for CMake import and packaging"
+    inputs.file(archiveFile)
+    outputs.dir(outputDir)
+
+    doLast {
+      outputDir.deleteDir()
+      new TarArchiveInputStream(
+        new XZInputStream(archiveFile.newInputStream())
+      ).withCloseable { tar ->
+        def entry
+        while ((entry = tar.nextEntry) != null) {
+          if (entry.isDirectory()) {
+            continue
+          }
+          // entries are `<variant>/<abi>/lib*.so`
+          def dest = new File(outputDir, entry.name)
+          dest.parentFile.mkdirs()
+          dest.withOutputStream { out -> tar.transferTo(out) }
+        }
+      }
+    }
+  }
+
+  tasks.named("preBuild").configure { dependsOn(decompressPrebuiltNativeLibs) }
+}

package/android/cmake/jsi.cmake

@@ -3,7 +3,7 @@ file(GLOB android_sources_jsi "${ANDROID_SRC_DIR}/jsi/*.cpp")
 
 add_library(
   expo-modules-jsi
-  STATIC
+  SHARED
   ${common_sources_jsi}
   ${android_sources_jsi}
 )

package/android/cmake/prebuilt.cmake

@@ -0,0 +1,34 @@
+if (${CMAKE_BUILD_TYPE} MATCHES "Debug")
+  set(EXPO_PREBUILT_VARIANT "debug")
+else ()
+  set(EXPO_PREBUILT_VARIANT "release")
+endif ()
+
+set(EXPO_PREBUILT_ABI_DIR "${EXPO_PREBUILT_NATIVE_LIBS_DIR}/${EXPO_PREBUILT_VARIANT}/${ANDROID_ABI}")
+
+# expo-modules-jsi
+set(EXPO_PREBUILT_JSI_SO "${EXPO_PREBUILT_ABI_DIR}/libexpo-modules-jsi.so")
+if (EXISTS "${EXPO_PREBUILT_JSI_SO}")
+  add_library(expo-modules-jsi SHARED IMPORTED)
+  set_target_properties(
+    expo-modules-jsi
+    PROPERTIES
+    IMPORTED_LOCATION "${EXPO_PREBUILT_JSI_SO}"
+    INTERFACE_INCLUDE_DIRECTORIES "${COMMON_DIR}/JSI;${ANDROID_SRC_DIR}/jsi"
+  )
+  set(EXPO_JSI_PREBUILT TRUE)
+  message(STATUS "[expo-modules-core] Using prebuilt libexpo-modules-jsi.so (${EXPO_PREBUILT_VARIANT}/${ANDROID_ABI})")
+endif ()
+
+# expo-modules-core
+set(EXPO_PREBUILT_CORE_SO "${EXPO_PREBUILT_ABI_DIR}/libexpo-modules-core.so")
+if (EXISTS "${EXPO_PREBUILT_CORE_SO}")
+  add_library(expo-modules-core SHARED IMPORTED)
+  set_target_properties(
+    expo-modules-core
+    PROPERTIES
+    IMPORTED_LOCATION "${EXPO_PREBUILT_CORE_SO}"
+  )
+  set(EXPO_CORE_PREBUILT TRUE)
+  message(STATUS "[expo-modules-core] Using prebuilt libexpo-modules-core.so (${EXPO_PREBUILT_VARIANT}/${ANDROID_ABI})")
+endif ()

package/android/prebuilt/metadata.json

@@ -0,0 +1,20 @@
+{
+    "libraryVersion": "58.0.1",
+    "reactNativeVersion": "0.88.0",
+    "variants": [
+        "debug",
+        "release"
+    ],
+    "abis": [
+        "arm64-v8a",
+        "armeabi-v7a",
+        "x86",
+        "x86_64"
+    ],
+    "soFiles": [
+        "libexpo-modules-core.so",
+        "libexpo-modules-jsi.so"
+    ],
+    "stripped": true,
+    "createdAt": "2026-09-15T14:36:32.485597Z"
+}

package/android/src/main/cpp/ArrayBuffer.cpp

@@ -1,4 +1,5 @@
 #include "ArrayBuffer.h"
+#include "MutableBufferNativeState.h"
 
 #include "Exceptions.h"
 #include "JavaReferencesCache.h"
@@ -184,7 +185,7 @@ jni::local_ref<ArrayBuffer::javaobject> makeArrayBufferFromJSIArrayBuffer(
   size_t length,
   const std::function<uint8_t *(jsi::ArrayBuffer &)> &copySourceProvider
 ) {
-  auto mutableBuffer = arrayBuffer.tryGetMutableBuffer(runtime);
+  auto mutableBuffer = expo::tryGetMutableBuffer(runtime, arrayBuffer);
   if (mutableBuffer) {
     return makeArrayBufferObject(
       jsiContext,
@@ -285,7 +286,7 @@ std::shared_ptr<jsi::MutableBuffer> ByteBufferArrayBufferStorage::jsiMutableBuff
 }
 
 jsi::Value ByteBufferArrayBufferStorage::toJSIValue(jsi::Runtime &runtime) {
-  return jsi::Value(runtime, runtime.createArrayBuffer(jsiMutableBuffer()));
+  return jsi::Value(runtime, createNativeBackedArrayBuffer(runtime, jsiMutableBuffer()));
 }
 
 jni::local_ref<jni::JObject> ByteBufferArrayBufferStorage::withJSBytes(
@@ -328,7 +329,7 @@ std::shared_ptr<jsi::MutableBuffer> MutableBufferViewArrayBufferStorage::jsiMuta
 }
 
 jsi::Value MutableBufferViewArrayBufferStorage::toJSIValue(jsi::Runtime &runtime) {
-  return jsi::Value(runtime, runtime.createArrayBuffer(jsiMutableBuffer()));
+  return jsi::Value(runtime, createNativeBackedArrayBuffer(runtime, jsiMutableBuffer()));
 }
 
 jni::local_ref<jni::JObject> MutableBufferViewArrayBufferStorage::withJSBytes(
@@ -446,11 +447,11 @@ jsi::Value JavaScriptBackedArrayBufferStorage::toJSIValue(jsi::Runtime &runtime)
       }
       auto byteBuffer = copyToDirectBuffer(_arrayBuffer->data(runtime) + _offset, _length);
       auto mutableBuffer = std::make_shared<ByteBufferJSIMutableBuffer>(byteBuffer);
-      return jsi::Value(runtime, runtime.createArrayBuffer(std::move(mutableBuffer)));
+      return jsi::Value(runtime, createNativeBackedArrayBuffer(runtime, std::move(mutableBuffer)));
     }
   }
 
-  return jsi::Value(runtime, runtime.createArrayBuffer(jsiMutableBuffer()));
+  return jsi::Value(runtime, createNativeBackedArrayBuffer(runtime, jsiMutableBuffer()));
 }
 
 jni::local_ref<jni::JObject> JavaScriptBackedArrayBufferStorage::withJSBytes(

package/android/src/main/cpp/MutableBufferNativeState.cpp

@@ -0,0 +1,36 @@
+#include "MutableBufferNativeState.h"
+
+namespace expo {
+
+MutableBufferNativeState::MutableBufferNativeState(std::shared_ptr<jsi::MutableBuffer> buffer)
+  : buffer(std::move(buffer)) {}
+
+jsi::ArrayBuffer createNativeBackedArrayBuffer(
+  jsi::Runtime &runtime,
+  std::shared_ptr<jsi::MutableBuffer> buffer
+) {
+  auto arrayBuffer = runtime.createArrayBuffer(buffer);
+  arrayBuffer.setNativeState(runtime, std::make_shared<MutableBufferNativeState>(std::move(buffer)));
+  return arrayBuffer;
+}
+
+std::shared_ptr<jsi::MutableBuffer> tryGetMutableBuffer(
+  jsi::Runtime &runtime,
+  const jsi::ArrayBuffer &arrayBuffer
+) {
+  if (auto buffer = arrayBuffer.tryGetMutableBuffer(runtime)) {
+    return buffer;
+  }
+
+  if (!arrayBuffer.hasNativeState<MutableBufferNativeState>(runtime)) {
+    return nullptr;
+  }
+
+  auto buffer = arrayBuffer.getNativeState<MutableBufferNativeState>(runtime)->buffer;
+  if (!buffer || arrayBuffer.data(runtime) != buffer->data()) {
+    return nullptr;
+  }
+  return buffer;
+}
+
+} // namespace expo

package/android/src/main/cpp/MutableBufferNativeState.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "ExpoHeader.pch"
+
+namespace expo {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Native state attached to every native-backed `jsi::ArrayBuffer` created by Expo.
+ * It retains the `jsi::MutableBuffer` that owns the bytes, so the buffer can be recovered
+ * later with `expo::tryGetMutableBuffer` even when the runtime doesn't implement
+ * `jsi::Runtime::tryGetMutableBuffer`. Hermes V1 returns `nullptr` from that method,
+ * which would otherwise force a copy and break the zero-copy contract.
+ */
+class MutableBufferNativeState final : public jsi::NativeState {
+public:
+  explicit MutableBufferNativeState(std::shared_ptr<jsi::MutableBuffer> buffer);
+
+  std::shared_ptr<jsi::MutableBuffer> buffer;
+};
+
+/**
+ * Creates a JS `ArrayBuffer` that shares the bytes of `buffer` and tags it with
+ * `MutableBufferNativeState`, so `expo::tryGetMutableBuffer` can find the buffer again.
+ */
+jsi::ArrayBuffer createNativeBackedArrayBuffer(
+  jsi::Runtime &runtime,
+  std::shared_ptr<jsi::MutableBuffer> buffer
+);
+
+/**
+ * Returns the `jsi::MutableBuffer` backing `arrayBuffer`, or `nullptr` when the bytes live
+ * on the JS heap. Asks the runtime first and falls back to the native state attached by
+ * `createNativeBackedArrayBuffer`. The fallback is used only when the JS object still points
+ * at the retained buffer's memory, so a detached or re-attached `ArrayBuffer` is never shared.
+ */
+std::shared_ptr<jsi::MutableBuffer> tryGetMutableBuffer(
+  jsi::Runtime &runtime,
+  const jsi::ArrayBuffer &arrayBuffer
+);
+
+} // namespace expo

package/android/src/main/cpp/NativeArrayBuffer.cpp

@@ -1,4 +1,5 @@
 #include "NativeArrayBuffer.h"
+#include "MutableBufferNativeState.h"
 
 #include "JavaScriptRuntime.h"
 #include "JSIContext.h"
@@ -57,7 +58,7 @@ NativeArrayBuffer::initHybrid(jni::alias_ref<JavaPart::javaobject>,
 jni::local_ref<NativeArrayBuffer::javaobject>
 NativeArrayBuffer::newInstance(JSIContext *jsiContext, jsi::Runtime &runtime,
                                jsi::ArrayBuffer &arrayBuffer) {
-  auto mutableBuffer = arrayBuffer.tryGetMutableBuffer(runtime);
+  auto mutableBuffer = expo::tryGetMutableBuffer(runtime, arrayBuffer);
   if (mutableBuffer) {
     auto byteBuffer = jni::JByteBuffer::wrapBytes(mutableBuffer->data(), mutableBuffer->size());
     byteBuffer->order(jni::JByteOrder::nativeOrder());
@@ -82,7 +83,7 @@ NativeArrayBuffer::newInstance(JSIContext *jsiContext, jsi::Runtime &runtime,
   size_t size = typedArray.byteLength(runtime);
 
   auto backingBuffer = typedArray.getBuffer(runtime);
-  auto mutableBuffer = backingBuffer.tryGetMutableBuffer(runtime);
+  auto mutableBuffer = expo::tryGetMutableBuffer(runtime, backingBuffer);
   if (mutableBuffer) {
     size_t offset = typedArray.byteOffset(runtime);
     auto byteBuffer = jni::JByteBuffer::wrapBytes(

package/android/src/main/cpp/NativeArrayBuffer.h

@@ -56,7 +56,7 @@ public:
 
   /**
    * Creates a NativeArrayBuffer from the given ArrayBuffer. Uses zero-copy when the
-   * buffer is native-backed (tryGetMutableBuffer), otherwise copies the data.
+   * buffer is native-backed (`expo::tryGetMutableBuffer`), otherwise copies the data.
    */
   static jni::local_ref<NativeArrayBuffer::javaobject> newInstance(
     JSIContext *jsiContext,

package/android/src/main/cpp/types/JNIToJSIConverter.h

@@ -10,6 +10,7 @@
 #include "ObjectDeallocator.h"
 #include "../JavaScriptArrayBuffer.h"
 #include "../NativeArrayBuffer.h"
+#include "../MutableBufferNativeState.h"
 #include "../concepts/jni_deref.h"
 #include "../concepts/jni.h"
 #include "../concepts/jsi.h"
@@ -182,7 +183,7 @@ struct JNIToJSIConverter<JavaScriptArrayBuffer *> {
 template<>
 struct JNIToJSIConverter<NativeArrayBuffer *> {
   static jsi::Value convert(JNIEnv *, jsi::Runtime &rt, NativeArrayBuffer *value) {
-    jsi::ArrayBuffer arrayBuffer(rt, value->jsiMutableBuffer());
+    auto arrayBuffer = createNativeBackedArrayBuffer(rt, value->jsiMutableBuffer());
     return jsi::Value{rt, arrayBuffer};
   }
 };

package/android/src/main/java/expo/modules/v2/ExpoModulesV2Host.kt

@@ -2,7 +2,7 @@ package expo.modules.v2
 
 import com.facebook.react.bridge.ReactApplicationContext
 import expo.modules.kotlin.logger
-import io.github.expo.modules.v2.modules.Module
+import io.github.expo.modules.v2.Module
 import io.github.expo.modules.v2.modules.ModuleRegistry
 import io.github.expo.modules.v2.react.ReactRuntime
 import java.lang.reflect.Modifier

package/android/src/main/java/expo/modules/v2/ExpoModulesV2Provider.kt

@@ -1,6 +1,6 @@
 package expo.modules.v2
 
-import io.github.expo.modules.v2.modules.Module
+import io.github.expo.modules.v2.Module
 
 interface ExpoModulesV2Provider {
   fun getModules(): List<Class<out Module>>

package/expo-module-gradle-plugin/build.gradle.kts

@@ -29,11 +29,11 @@ val isExpoAutolinkingSettingsPluginAvailable = expoAutolinkingSettingsPlugin ==
 
 dependencies {
   implementation(gradleApi())
-  compileOnly("com.android.tools.build:gradle:8.5.0")
+  compileOnly("com.android.tools.build:gradle:9.2.1")
   implementation("com.facebook.react:react-native-gradle-plugin")
   implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
   implementation("io.github.expo.pika:pika-gradle:1.0.0")
-  implementation("io.github.expo:expo-modules-v2-gradle-plugin:0.1.2")
+  implementation("io.github.expo:expo-modules-v2-gradle-plugin:0.1.5")
 
   if (isExpoAutolinkingSettingsPluginAvailable) {
     implementation("expo.modules:expo-autolinking-plugin-shared")

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

@@ -3,7 +3,6 @@
 package expo.modules.plugin
 
 import com.android.build.api.dsl.LibraryExtension
-import com.android.build.api.variant.AndroidComponentsExtension
 import expo.modules.plugin.android.PublicationInfo
 import expo.modules.plugin.android.applyLinterOptions
 import expo.modules.plugin.android.applyPublishingVariant
@@ -132,18 +131,11 @@ internal fun Project.applyPublishing(expoModulesExtension: ExpoModuleExtension)
   }
 }
 
-private const val AGP_BUILT_IN_KOTLIN_MAJOR = 9
-
 /**
  * Whether AGP's built-in Kotlin support is active, meaning the `kotlin-android` plugin must not be
- * applied. True on AGP 9+ unless the project explicitly opts out with `android.builtInKotlin=false`.
+ * applied. AGP 9 enables it by default unless the project explicitly opts out with `android.builtInKotlin=false`.
  */
 internal fun Project.hasBuiltInKotlinSupport(): Boolean {
-  val androidComponents = extensions.findByType(AndroidComponentsExtension::class.java)
-    ?: return false
-  if (androidComponents.pluginVersion.major < AGP_BUILT_IN_KOTLIN_MAJOR) {
-    return false
-  }
   return findProperty("android.builtInKotlin")?.toString()?.toBoolean() ?: true
 }
 

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

@@ -19,6 +19,10 @@ data class Version(
     return major * 10000 + minor * 100 + patch
   }
 
+  override fun toString(): String {
+    return "${major}.${minor}.${patch}"
+  }
+
   companion object {
     fun fromString(value: String): Version {
       // strip pre-release

package/ios/Platform/Platform.swift

@@ -16,6 +16,9 @@ public typealias UILabel = NSLabel
 public typealias UIImage = NSImage
 public typealias UIImageView = NSImageView
 public typealias UIPasteboard = NSPasteboard
+public typealias UIColor = NSColor
+public typealias UIGestureRecognizer = NSGestureRecognizer
+public typealias UITextContentType = NSTextContentType
 
 extension UIApplication {
   public typealias LaunchOptionsKey = String

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "58.0.1",
+  "version": "58.0.2",
   "description": "The core of Expo Modules architecture",
   "keywords": [
     "expo",
@@ -65,7 +65,7 @@
   },
   "dependencies": {
     "@expo/expo-modules-macros-plugin": "0.10.0",
-    "expo-modules-jsi": "~58.0.1",
+    "expo-modules-jsi": "~58.0.2",
     "invariant": "^2.2.4"
   },
   "devDependencies": {
@@ -84,7 +84,7 @@
       "optional": true
     }
   },
-  "gitHead": "40afe3afa42f1dcca3dcba7ffbb3641859bdf2f0",
+  "gitHead": "313e67f5c9dfb16f9deca74a271cd1d4f33a6f82",
   "scripts": {
     "build": "expo-build src",
     "precompile-ios": "et prebuild-package-for-publish",