expo-modules-core 56.0.6 → 56.0.8

package/CHANGELOG.md

@@ -10,6 +10,19 @@
 
 ### 💡 Others
 
+## 56.0.8 — 2026-05-13
+
+### 🐛 Bug fixes
+
+- [Android] Avoid remounting Jetpack Compose views during same-frame React Native reparenting. ([#45711](https://github.com/expo/expo/pull/45711) by [@mvincentong](https://github.com/mvincentong))
+- [Android] Fixed `associatedCookies` in `Network.requestWillBeSentExtraInfo` CDP events serializing as a JSON object instead of an array. ([#45720](https://github.com/expo/expo/pull/45720) by [@huntie](https://github.com/huntie))
+
+## 56.0.7 — 2026-05-13
+
+### 🐛 Bug fixes
+
+- [iOS] Fix encoding `Encodable` function results so arrays, dictionaries, optionals, `RawRepresentable` enums and `Convertible`s route through their dynamic types instead of producing wrong shapes. ([#45575](https://github.com/expo/expo/pull/45575) by [@tsapeta](https://github.com/tsapeta))
+
 ## 56.0.6 — 2026-05-11
 
 ### 💡 Others

package/android/build.gradle

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

package/android/src/compose/expo/modules/kotlin/views/ExpoComposeView.kt

@@ -193,13 +193,11 @@ abstract class ExpoComposeView<T : ComposeProps>(
           Content()
         }
       }
-      it.addOnAttachStateChangeListener(object : OnAttachStateChangeListener {
-        override fun onViewAttachedToWindow(v: View) {
+      it.addOnAttachStateChangeListener(
+        OnAttachAfterDetachmentListener(onAttachAfterDetachment = {
           it.disposeComposition()
-        }
-
-        override fun onViewDetachedFromWindow(v: View) = Unit
-      })
+        })
+      )
     }
     addView(composeView)
   }

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

@@ -7,22 +7,13 @@
 #include "JavaScriptModuleObject.h"
 #include "JavaScriptValue.h"
 #include "JavaScriptObject.h"
-#include "JavaReferencesCache.h"
 #include "JSReferencesCache.h"
 #include "JNIDeallocator.h"
 #include "ThreadSafeJNIGlobalRef.h"
 #include "javaclasses/JSRunnable.h"
 
-#include <ReactCommon/CallInvokerHolder.h>
 #include <ReactCommon/CallInvoker.h>
 
-#if IS_NEW_ARCHITECTURE_ENABLED
-
-#include <ReactCommon/RuntimeExecutor.h>
-#include <react/jni/JRuntimeExecutor.h>
-
-#endif
-
 namespace jni = facebook::jni;
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;

package/android/src/main/cpp/JavaCallback.cpp

@@ -60,10 +60,8 @@ jni::local_ref<JavaCallback::javaobject> JavaCallback::newInstance(
   return object;
 }
 
-template<typename T>
-void JavaCallback::invokeJSFunction(
-  ArgsConverter<typename std::remove_const<T>::type> argsConverter,
-  T arg
+void JavaCallback::invokeWithResolver(
+  std::function<void(jsi::Runtime &rt, jsi::Function &jsFunction)> resolver
 ) {
   const auto strongCallbackContext = this->callbackContext.lock();
   // The context were deallocated before the callback was invoked.
@@ -80,8 +78,7 @@ void JavaCallback::invokeJSFunction(
   jsInvoker->invokeAsync(
     [
       context = callbackContext,
-      argsConverter = std::move(argsConverter),
-      arg = std::move(arg)
+      resolver = std::move(resolver)
     ]() -> void {
       auto strongContext = context.lock();
       // The context were deallocated before the callback was invoked.
@@ -98,25 +95,11 @@ void JavaCallback::invokeJSFunction(
       jsi::Function &jsFunction = strongContext->resolveHolder.value();
       jsi::Runtime &rt = strongContext->rt;
 
-      argsConverter(rt, jsFunction, std::move(arg));
+      resolver(rt, jsFunction);
       strongContext->invalidate();
     });
 }
 
-template<class T>
-void JavaCallback::invokeJSFunction(T arg) {
-  invokeJSFunction<T>(
-    [](
-      jsi::Runtime &rt,
-      jsi::Function &jsFunction,
-      T arg
-    ) {
-      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, std::forward<T>(arg)));
-    },
-    arg
-  );
-}
-
 template<class T>
 void JavaCallback::invokeJSFunctionForArray(T &arg) {
   size_t size = arg->size();
@@ -125,38 +108,51 @@ void JavaCallback::invokeJSFunctionForArray(T &arg) {
   rawArray.size = size;
   rawArray.data = std::move(region);
 
-  invokeJSFunction<decltype(rawArray)>(
-    std::move(rawArray)
+  invokeWithResolver(
+    [rawArray = std::move(rawArray)](jsi::Runtime &rt, jsi::Function &jsFunction) mutable {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, std::move(rawArray)));
+    }
   );
 }
 
 void JavaCallback::invoke() {
-  invokeJSFunction<nullptr_t>(
-    [](
-      jsi::Runtime &rt,
-      jsi::Function &jsFunction,
-      nullptr_t arg
-    ) {
+  invokeWithResolver(
+    [](jsi::Runtime &rt, jsi::Function &jsFunction) {
       jsFunction.call(rt, {jsi::Value::null()});
-    },
-    nullptr
+    }
   );
 }
 
 void JavaCallback::invokeBool(bool result) {
-  invokeJSFunction(result);
+  invokeWithResolver(
+    [result](jsi::Runtime &rt, jsi::Function &jsFunction) {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, result));
+    }
+  );
 }
 
 void JavaCallback::invokeInt(int result) {
-  invokeJSFunction(result);
+  invokeWithResolver(
+    [result](jsi::Runtime &rt, jsi::Function &jsFunction) {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, result));
+    }
+  );
 }
 
 void JavaCallback::invokeDouble(double result) {
-  invokeJSFunction(result);
+  invokeWithResolver(
+    [result](jsi::Runtime &rt, jsi::Function &jsFunction) {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, result));
+    }
+  );
 }
 
 void JavaCallback::invokeFloat(float result) {
-  invokeJSFunction(result);
+  invokeWithResolver(
+    [result](jsi::Runtime &rt, jsi::Function &jsFunction) {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, result));
+    }
+  );
 }
 
 void JavaCallback::invokeString(jni::alias_ref<jstring> result) {
@@ -164,41 +160,76 @@ void JavaCallback::invokeString(jni::alias_ref<jstring> result) {
   const char *rawValue = env->GetStringUTFChars(result.get(), nullptr);
   std::string parsedResult = rawValue;
   env->ReleaseStringUTFChars(result.get(), rawValue);
-  invokeJSFunction(parsedResult);
+  invokeWithResolver(
+    [parsedResult = std::move(parsedResult)](jsi::Runtime &rt, jsi::Function &jsFunction) {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, parsedResult));
+    }
+  );
 }
 
 void JavaCallback::invokeCollection(jni::alias_ref<jni::JCollection<jobject>> result) {
-  invokeJSFunction<
-    jni::global_ref<jni::JCollection<jobject>>
-  >(jni::make_global(result));
+  jni::global_ref<jni::JCollection<jobject>> globalResult = jni::make_global(result);
+  invokeWithResolver(
+    [globalResult = std::move(globalResult)](jsi::Runtime &rt, jsi::Function &jsFunction) mutable {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, std::move(globalResult)));
+    }
+  );
 }
 
 void JavaCallback::invokeMap(jni::alias_ref<jni::JMap<jstring, jobject>> result) {
-  invokeJSFunction<
-    jni::global_ref<jni::JMap<jstring, jobject>>
-  >(jni::make_global(result));
+  jni::global_ref<jni::JMap<jstring, jobject>> globalResult = jni::make_global(result);
+  invokeWithResolver(
+    [globalResult = std::move(globalResult)](jsi::Runtime &rt, jsi::Function &jsFunction) mutable {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, std::move(globalResult)));
+    }
+  );
 }
 
 void
 JavaCallback::invokeWritableArray(jni::alias_ref<react::WritableNativeArray::javaobject> result) {
-  invokeJSFunction(result->cthis()->consume());
+  auto consumed = result->cthis()->consume();
+  invokeWithResolver(
+    [consumed = std::move(consumed)](jsi::Runtime &rt, jsi::Function &jsFunction) mutable {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, std::move(consumed)));
+    }
+  );
 }
 
 void JavaCallback::invokeWritableMap(jni::alias_ref<react::WritableNativeMap::javaobject> result) {
-  invokeJSFunction(result->cthis()->consume());
+  auto consumed = result->cthis()->consume();
+  invokeWithResolver(
+    [consumed = std::move(consumed)](jsi::Runtime &rt, jsi::Function &jsFunction) mutable {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, std::move(consumed)));
+    }
+  );
 }
 
 void JavaCallback::invokeSharedObject(jni::alias_ref<JSharedObject::javaobject> result) {
-  invokeJSFunction(jni::make_global(result));
+  auto globalResult = jni::make_global(result);
+  invokeWithResolver(
+    [globalResult = std::move(globalResult)](jsi::Runtime &rt, jsi::Function &jsFunction) mutable {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, std::move(globalResult)));
+    }
+  );
 }
 
 void JavaCallback::invokeJavaScriptArrayBuffer(
   jni::alias_ref<JavaScriptArrayBuffer::javaobject> result) {
-  invokeJSFunction(jni::make_global(result));
+  auto globalResult = jni::make_global(result);
+  invokeWithResolver(
+    [globalResult = std::move(globalResult)](jsi::Runtime &rt, jsi::Function &jsFunction) mutable {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, std::move(globalResult)));
+    }
+  );
 }
 
 void JavaCallback::invokeNativeArrayBuffer(jni::alias_ref<NativeArrayBuffer::javaobject> result) {
-  invokeJSFunction(jni::make_global(result));
+  auto globalResult = jni::make_global(result);
+  invokeWithResolver(
+    [globalResult = std::move(globalResult)](jsi::Runtime &rt, jsi::Function &jsFunction) mutable {
+      jsFunction.call(rt, convertToJS(jni::Environment::current(), rt, std::move(globalResult)));
+    }
+  );
 }
 
 void JavaCallback::invokeIntArray(jni::alias_ref<jni::JArrayInt> result) {

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

@@ -90,19 +90,9 @@ private:
   void invokeDoubleArray(jni::alias_ref<jni::JArrayDouble> result);
   void invokeFloatArray(jni::alias_ref<jni::JArrayFloat> result);
 
-  template<class T>
-  using ArgsConverter = std::function<void(jsi::Runtime &rt, jsi::Function &jsFunction, T arg)>;
-
-  template<class T>
-  inline void invokeJSFunction(
-    ArgsConverter<typename std::remove_const<T>::type> argsConverter,
-    T arg
-  );
+  void invokeWithResolver(std::function<void(jsi::Runtime &rt, jsi::Function &jsFunction)> resolver);
 
   template<class T>
   void invokeJSFunctionForArray(T &arg);
-
-  template<class T>
-  inline void invokeJSFunction(T arg);
 };
 } // namespace expo

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

@@ -5,7 +5,6 @@
 #include "ExpoHeader.pch"
 #include "JSIObjectWrapper.h"
 #include "JavaScriptTypedArray.h"
-#include "JavaScriptArrayBuffer.h"
 #include "JNIDeallocator.h"
 
 namespace jni = facebook::jni;

package/android/src/main/cpp/decorators/JSDecoratorsBridgingObject.cpp

@@ -2,11 +2,21 @@
 
 #include "JSDecoratorsBridgingObject.h"
 
+#include "JSFunctionsDecorator.h"
+#include "JSPropertiesDecorator.h"
+#include "JSConstantsDecorator.h"
+#include "JSObjectDecorator.h"
 #include "JSClassesDecorator.h"
 #include "../types/ReturnType.h"
 
 namespace expo {
 
+JSDecoratorsBridgingObject::~JSDecoratorsBridgingObject() = default;
+
+JSClassesDecorator* JSDecoratorsBridgingObject::getClassDecorator() const {
+  return classDecorator.get();
+}
+
 jni::local_ref<jni::HybridClass<JSDecoratorsBridgingObject>::jhybriddata>
 JSDecoratorsBridgingObject::initHybrid(jni::alias_ref<jhybridobject> jThis) {
   return makeCxxInstance();

package/android/src/main/cpp/decorators/JSDecoratorsBridgingObject.h

@@ -8,18 +8,20 @@
 #include "../JNIFunctionBody.h"
 #include "../types/ExpectedType.h"
 
-#include "JSFunctionsDecorator.h"
-#include "JSPropertiesDecorator.h"
-#include "JSConstantsDecorator.h"
-#include "JSObjectDecorator.h"
-#include "JSClassesDecorator.h"
-
 namespace jni = facebook::jni;
 
 namespace expo {
 
+class JSFunctionsDecorator;
+class JSPropertiesDecorator;
+class JSConstantsDecorator;
+class JSObjectDecorator;
+class JSClassesDecorator;
+
 class JSDecoratorsBridgingObject : public jni::HybridClass<JSDecoratorsBridgingObject> {
 public:
+  ~JSDecoratorsBridgingObject();
+
   static auto constexpr
     kJavaDescriptor = "Lexpo/modules/kotlin/jni/decorators/JSDecoratorsBridgingObject;";
   static auto constexpr TAG = "JSDecoratorsBridgingObject";
@@ -87,9 +89,7 @@ public:
   /**
    * Returns the class decorator, or nullptr if none was registered.
    */
-  JSClassesDecorator* getClassDecorator() const {
-    return classDecorator.get();
-  }
+  JSClassesDecorator* getClassDecorator() const;
 
 private:
   friend HybridBase;

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

@@ -1,5 +1,6 @@
 #include "NativeStatePropsGetter.h"
 #include "AndroidExpoViewState.h"
+#include <react/fabric/StateWrapperImpl.h>
 
 #include <react/renderer/core/ConcreteState.h>
 

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

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "../ExpoHeader.pch"
-#include <react/fabric/StateWrapperImpl.h>
 
 namespace jni = facebook::jni;
 namespace react = facebook::react;

package/android/src/main/java/expo/modules/kotlin/devtools/cdp/CdpNetworkTypes.kt

@@ -5,6 +5,7 @@ package expo.modules.kotlin.devtools.cdp
 import expo.modules.kotlin.devtools.ExpoNetworkInspectOkHttpNetworkInterceptor
 import expo.modules.kotlin.devtools.toSingleMap
 import okio.Buffer
+import org.json.JSONArray
 import org.json.JSONObject
 import java.math.BigDecimal
 
@@ -155,7 +156,7 @@ data class RequestWillBeSentParams(
 
 data class RequestWillBeSentExtraInfoParams(
   val requestId: RequestId,
-  val associatedCookies: Map<String, String> = emptyMap(),
+  val associatedCookies: List<Any> = emptyList(),
   val headers: Headers,
   val connectTiming: ConnectTiming
 ) : JsonSerializable {
@@ -168,7 +169,7 @@ data class RequestWillBeSentExtraInfoParams(
   override fun toJSONObject(): JSONObject {
     return JSONObject().apply {
       put("requestId", requestId)
-      put("associatedCookies", JSONObject(associatedCookies))
+      put("associatedCookies", JSONArray(associatedCookies))
       put("headers", JSONObject(headers))
       put("connectTiming", connectTiming.toJSONObject())
     }

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

@@ -0,0 +1,41 @@
+package expo.modules.kotlin.views
+
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+
+/**
+ * Runs a callback only when a view is attached after staying detached through one main-loop turn.
+ * React Native can synchronously detach and reattach native children during view reparenting, and
+ * those moves should not be treated like a full detach.
+ */
+internal class OnAttachAfterDetachmentListener(
+  private val onAttachAfterDetachment: () -> Unit,
+  private val post: (Runnable) -> Unit = { runnable ->
+    Handler(Looper.getMainLooper()).post(runnable)
+  }
+) : View.OnAttachStateChangeListener {
+  private var shouldRunOnAttach = false
+  private var detachGeneration = 0
+
+  override fun onViewAttachedToWindow(v: View) {
+    detachGeneration += 1
+
+    if (shouldRunOnAttach) {
+      shouldRunOnAttach = false
+      onAttachAfterDetachment()
+    }
+  }
+
+  override fun onViewDetachedFromWindow(v: View) {
+    val generation = ++detachGeneration
+
+    post(
+      Runnable {
+        if (detachGeneration == generation && !v.isAttachedToWindow) {
+          shouldRunOnAttach = true
+        }
+      }
+    )
+  }
+}

package/build/polyfill/CoreModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CoreModule.d.ts","sourceRoot":"","sources":["../../src/polyfill/CoreModule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,IAAI,gBAAgB,EAChC,iBAAiB,EAClB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxF,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxF,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE/E,qBAAa,YAAY,CAAC,UAAU,SAAS,SAAS,CAAE,YAAW,gBAAgB;IACjF,OAAO,CAAC,SAAS,CAAC,CAAuC;IAEzD,WAAW,CAAC,SAAS,SAAS,MAAM,UAAU,EAC5C,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,UAAU,CAAC,SAAS,CAAC,GAC9B,iBAAiB;IAuBpB,cAAc,CAAC,SAAS,SAAS,MAAM,UAAU,EAC/C,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,UAAU,CAAC,SAAS,CAAC,GAC9B,IAAI;IAOP,kBAAkB,CAAC,SAAS,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAQlF,IAAI,CAAC,SAAS,SAAS,MAAM,UAAU,EACrC,SAAS,EAAE,SAAS,EACpB,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,GACzC,IAAI;IAeP,aAAa,CAAC,SAAS,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM;IAI/E,cAAc,CAAC,SAAS,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAE9E,aAAa,CAAC,SAAS,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;CAC9E;AAED,qBAAa,YAAY,CAAC,UAAU,SAAS,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAC/D,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,gBAAgB;IAE3B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB,cAAc,CAAC,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAChD,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,qBAAa,YAAY,CAAC,UAAU,SAAS,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAC/D,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,gBAAgB;IAE3B,OAAO,IAAI,IAAI;CAGhB;AAED,qBAAa,SAAS,CAClB,cAAc,SAAS,MAAM,GAAG,SAAS,EACzC,UAAU,SAAS,SAAS,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAErD,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,aAAa,CAAC,cAAc,CAAC;IAExC,aAAa,EAAE,MAAM,CAAa;CACnC"}
+{"version":3,"file":"CoreModule.d.ts","sourceRoot":"","sources":["../../src/polyfill/CoreModule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,IAAI,gBAAgB,EAChC,iBAAiB,EAClB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxF,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxF,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE/E,qBAAa,YAAY,CAAC,UAAU,SAAS,SAAS,CAAE,YAAW,gBAAgB;IACjF,OAAO,CAAC,SAAS,CAAC,CAAuC;IAEzD,WAAW,CAAC,SAAS,SAAS,MAAM,UAAU,EAC5C,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,UAAU,CAAC,SAAS,CAAC,GAC9B,iBAAiB;IAuBpB,cAAc,CAAC,SAAS,SAAS,MAAM,UAAU,EAC/C,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,UAAU,CAAC,SAAS,CAAC,GAC9B,IAAI;IAOP,kBAAkB,CAAC,SAAS,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAQlF,IAAI,CAAC,SAAS,SAAS,MAAM,UAAU,EACrC,SAAS,EAAE,SAAS,EACpB,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,GACzC,IAAI;IAeP,aAAa,CAAC,SAAS,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM;IAI/E,cAAc,CAAC,SAAS,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAE9E,aAAa,CAAC,SAAS,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;CAC9E;AAED,qBAAa,YAAY,CAAC,UAAU,SAAS,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAC/D,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,gBAAgB;IAE3B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB,cAAc,CAAC,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAChD,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,qBAAa,YAAY,CAAC,UAAU,SAAS,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAC/D,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,gBAAgB;IAE3B,OAAO,IAAI,IAAI;CAGhB;AAED,qBAAa,SAAS,CACpB,cAAc,SAAS,MAAM,GAAG,SAAS,EACzC,UAAU,SAAS,SAAS,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAEnD,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,aAAa,CAAC,cAAc,CAAC;IAExC,aAAa,EAAE,MAAM,CAAa;CACnC"}

package/build/ts-declarations/SharedRef.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SharedRef.d.ts","sourceRoot":"","sources":["../../src/ts-declarations/SharedRef.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS,CAC1B,cAAc,SAAS,MAAM,GAAG,SAAS,EACzC,UAAU,SAAS,SAAS,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAErD,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,YAAY,CAAC,UAAU,CAAC;IAEnC;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,cAAc,CAAC;IAE7C;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB"}
+{"version":3,"file":"SharedRef.d.ts","sourceRoot":"","sources":["../../src/ts-declarations/SharedRef.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS,CAC5B,cAAc,SAAS,MAAM,GAAG,SAAS,EACzC,UAAU,SAAS,SAAS,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAEnD,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,YAAY,CAAC,UAAU,CAAC;IAEnC;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,cAAc,CAAC;IAE7C;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB"}

package/ios/Core/DynamicTypes/DynamicEncodableType.swift

@@ -29,15 +29,16 @@ internal struct DynamicEncodableType: AnyDynamicType {
   }
 
   func castToJS<ValueType>(_ value: ValueType, appContext: AppContext) throws -> JavaScriptValue {
+    return try castToJS(value, appContext: appContext, in: try appContext.runtime)
+  }
+
+  func castToJS<ValueType>(_ value: ValueType, appContext: AppContext, in runtime: JavaScriptRuntime) throws -> JavaScriptValue {
     if let value = value as? JavaScriptValue {
       return value
     }
     if let value = value as? Encodable {
-      let runtime = try appContext.runtime
-      let encoder = JSValueEncoder(runtime: runtime)
-
+      let encoder = JSValueEncoder(appContext: appContext, runtime: runtime)
       try value.encode(to: encoder)
-
       return encoder.value
     }
     throw Conversions.ConversionToJSFailedException((kind: .object, nativeType: ValueType.self))

package/ios/Core/JSValueEncoder.swift

@@ -3,12 +3,21 @@
 import ExpoModulesJSI
 
 /**
- Encodes `Encodable` objects or values to `JavaScriptValue`. This implementation is incomplete,
- but it supports basic use cases with structs defined by the user and when the default `Encodable` implementation is used.
+ Encodes `Encodable` values to `JavaScriptValue`.
+
+ For any property whose static type is known to the dynamic-type registry
+ (anything routed via the `~` operator: arrays, dictionaries, optionals,
+ `RawRepresentable` enums, `Convertible`s, `JavaScriptValue` and so on),
+ the encoder takes the fast path through `castToJS`, preserving full
+ element-type metadata.
+
+ Only types the registry doesn't recognize (i.e. plain `Encodable` structs and
+ classes) fall back to Swift's `Encodable` machinery via `value.encode(to:)`.
  */
 internal final class JSValueEncoder: Encoder {
+  private let appContext: AppContext
   private let runtime: JavaScriptRuntime
-  private let valueHolder = JSValueHolder()
+  private let valueHolder: JSValueHolder
 
   /**
    The result of encoding to `JavaScriptValue`. Use this property after running `encode(to:)` on the encodable.
@@ -18,43 +27,106 @@ internal final class JSValueEncoder: Encoder {
   }
 
   /**
-   Initializes the encoder with the given runtime in which the value will be created.
+   Initializes the encoder with the given app context. Throws if the runtime has been lost.
+   */
+  convenience init(appContext: AppContext) throws {
+    try self.init(appContext: appContext, runtime: appContext.runtime)
+  }
+
+  /**
+   Initializes the encoder with the given app context and an explicit runtime.
+   Use this when produced JS values must live in a runtime other than the
+   one currently held by the app context.
    */
-  init(runtime: JavaScriptRuntime) {
+  convenience init(appContext: AppContext, runtime: JavaScriptRuntime) {
+    self.init(
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: [],
+      valueHolder: JSValueHolder()
+    )
+  }
+
+  fileprivate init(
+    appContext: AppContext,
+    runtime: JavaScriptRuntime,
+    codingPath: [any CodingKey],
+    valueHolder: JSValueHolder
+  ) {
+    self.appContext = appContext
     self.runtime = runtime
+    self.codingPath = codingPath
+    self.valueHolder = valueHolder
   }
 
   // MARK: - Encoder
 
-  // We don't use `codingPath` and `userInfo`, but they are required by the protocol.
-  let codingPath: [any CodingKey] = []
+  let codingPath: [any CodingKey]
   let userInfo: [CodingUserInfoKey: Any] = [:]
 
-  /**
-   Returns an encoding container appropriate for holding multiple values keyed by the given key type.
-   */
   func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {
-    let container = JSObjectEncodingContainer<Key>(to: valueHolder, runtime: runtime)
+    let container = JSObjectEncodingContainer<Key>(
+      to: valueHolder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
     return KeyedEncodingContainer(container)
   }
 
-  /**
-   Returns an encoding container appropriate for holding multiple unkeyed values.
-   */
   func unkeyedContainer() -> any UnkeyedEncodingContainer {
-    return JSArrayEncodingContainer(to: valueHolder, runtime: runtime)
+    return JSArrayEncodingContainer(
+      to: valueHolder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
   }
 
-  /**
-   Returns an encoding container appropriate for holding a single primitive value, including optionals.
-   */
   func singleValueContainer() -> any SingleValueEncodingContainer {
-    return JSValueEncodingContainer(to: valueHolder, runtime: runtime)
+    return JSValueEncodingContainer(
+      to: valueHolder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
   }
 }
 
+// MARK: - Shared encoding logic
+
 /**
- An object that holds a JS value that could be overriden by the encoding container.
+ Encodes a single value into a `JavaScriptValue`, routing through the dynamic-type
+ registry whenever possible and falling back to `Encodable` only for plain types.
+ */
+private func encodeUsingDynamicType<ValueType: Encodable>(
+  _ value: ValueType,
+  appContext: AppContext,
+  runtime: JavaScriptRuntime,
+  codingPath: [any CodingKey]
+) throws -> JavaScriptValue {
+  let dynamicType = ~ValueType.self
+
+  if !(dynamicType is DynamicEncodableType) {
+    return try dynamicType.castToJS(value, appContext: appContext, in: runtime)
+  }
+
+  // Plain Encodable type the registry doesn't recognize — recurse via Encodable.
+  let holder = JSValueHolder()
+  let encoder = JSValueEncoder(
+    appContext: appContext,
+    runtime: runtime,
+    codingPath: codingPath,
+    valueHolder: holder
+  )
+  try value.encode(to: encoder)
+  return holder.value
+}
+
+// MARK: - Containers
+
+/**
+ An object that holds a JS value, mutated by an encoding container as it makes progress.
  */
 private final class JSValueHolder {
   var value: JavaScriptValue = .undefined
@@ -64,146 +136,233 @@ private final class JSValueHolder {
  Single value container used to encode primitive values, including optionals.
  */
 private struct JSValueEncodingContainer: SingleValueEncodingContainer {
-  private weak var runtime: JavaScriptRuntime?
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
   private let valueHolder: JSValueHolder
+  let codingPath: [any CodingKey]
 
-  init(to valueHolder: JSValueHolder, runtime: JavaScriptRuntime?) {
-    self.runtime = runtime
+  init(to valueHolder: JSValueHolder, appContext: AppContext, runtime: JavaScriptRuntime, codingPath: [any CodingKey]) {
     self.valueHolder = valueHolder
+    self.appContext = appContext
+    self.runtime = runtime
+    self.codingPath = codingPath
   }
 
-  // MARK: - SingleValueEncodingContainer
-
-  // Unused, but required by the protocol.
-  let codingPath: [any CodingKey] = []
-
   mutating func encodeNil() throws {
-    self.valueHolder.value = .null
+    valueHolder.value = .null
   }
 
   mutating func encode<ValueType: Encodable>(_ value: ValueType) throws {
-    guard let runtime else {
-      // Do nothing when the runtime is already deallocated
-      return
-    }
-    let jsValue = JavaScriptValue.from(value, runtime: runtime)
-
-    // If the given value couldn't be converted to JavaScriptValue, try to encode it farther.
-    // It might be the case when the default implementation of `Encodable` has chosen the single value container
-    // for an optional type that should rather use keyed or unkeyed container when unwrapped.
-    if jsValue.isUndefined() {
-      let encoder = JSValueEncoder(runtime: runtime)
-      try value.encode(to: encoder)
-      self.valueHolder.value = encoder.value
-      return
-    }
-    self.valueHolder.value = jsValue
+    valueHolder.value = try encodeUsingDynamicType(
+      value,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath
+    )
   }
 }
 
 /**
  Keyed container that encodes to a JavaScript object.
 
- - Note: This is a `class` (rather than `struct` like `JSArrayEncodingContainer` below)
-   because it holds a non-copyable `JavaScriptObject`. A struct property of a non-copyable
-   type makes the containing struct non-copyable too, which conflicts with
-   `KeyedEncodingContainerProtocol`'s expectation of a copyable conformer. Using a class
-   sidesteps the constraint via reference semantics.
+ - Note: This is a `class` (not a `struct`) because it holds a non-copyable
+   `JavaScriptObject`. A struct property of a non-copyable type makes the
+   containing struct non-copyable too, which conflicts with
+   `KeyedEncodingContainerProtocol`'s expectation of a copyable conformer.
+   Using a class sidesteps the constraint via reference semantics.
  */
-private class JSObjectEncodingContainer<Key: CodingKey>: KeyedEncodingContainerProtocol {
-  private weak var runtime: JavaScriptRuntime?
+private final class JSObjectEncodingContainer<Key: CodingKey>: KeyedEncodingContainerProtocol {
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
   private let valueHolder: JSValueHolder
-  private var object: JavaScriptObject
+  private let object: JavaScriptObject
+  let codingPath: [any CodingKey]
 
-  init(to valueHolder: JSValueHolder, runtime: JavaScriptRuntime) {
+  init(to valueHolder: JSValueHolder, appContext: AppContext, runtime: JavaScriptRuntime, codingPath: [any CodingKey]) {
     let object = runtime.createObject()
     valueHolder.value = object.asValue()
 
+    self.appContext = appContext
     self.runtime = runtime
-    self.object = object
     self.valueHolder = valueHolder
+    self.object = object
+    self.codingPath = codingPath
   }
 
-  // MARK: - KeyedEncodingContainerProtocol
-
-  // Unused, but required by the protocol.
-  var codingPath: [any CodingKey] = []
-
   func encodeNil(forKey key: Key) throws {
     object.setProperty(key.stringValue, value: JavaScriptValue.null)
   }
 
   func encode<ValueType: Encodable>(_ value: ValueType, forKey key: Key) throws {
-    guard let runtime else {
-      // Do nothing when the runtime is already deallocated
-      return
+    let encoded = try encodeUsingDynamicType(
+      value,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    object.setProperty(key.stringValue, value: encoded)
+  }
+
+  // The default `KeyedEncodingContainerProtocol.encodeIfPresent` does nothing for
+  // nil values, which leaves the JS object without the key entirely — so `'label' in obj`
+  // returns false and consumers can't distinguish "absent" from "explicitly null".
+  // Override every overload (one per primitive plus a generic `Encodable` one) so nil
+  // optional fields produce an explicit `null` instead.
+  func encodeIfPresent<ValueType: Encodable>(_ value: ValueType?, forKey key: Key) throws {
+    if let value {
+      try encode(value, forKey: key)
+    } else {
+      try encodeNil(forKey: key)
+    }
+  }
+
+  func encodeIfPresent(_ value: Bool?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: String?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Double?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Float?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int8?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int16?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int32?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: Int64?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt8?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt16?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt32?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+  func encodeIfPresent(_ value: UInt64?, forKey key: Key) throws { try encodeOptional(value, forKey: key) }
+
+  private func encodeOptional<ValueType: Encodable>(_ value: ValueType?, forKey key: Key) throws {
+    if let value {
+      try encode(value, forKey: key)
+    } else {
+      try encodeNil(forKey: key)
     }
-    let encoder = JSValueEncoder(runtime: runtime)
-    try value.encode(to: encoder)
-    object.setProperty(key.stringValue, value: encoder.value)
   }
 
   func nestedContainer<NestedKey: CodingKey>(keyedBy keyType: NestedKey.Type, forKey key: Key) -> KeyedEncodingContainer<NestedKey> {
-    fatalError("JSValueEncoder does not support nested containers")
+    let holder = JSValueHolder()
+    let container = JSObjectEncodingContainer<NestedKey>(
+      to: holder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    object.setProperty(key.stringValue, value: holder.value)
+    return KeyedEncodingContainer(container)
   }
 
   func nestedUnkeyedContainer(forKey key: Key) -> any UnkeyedEncodingContainer {
-    fatalError("JSValueEncoder does not support nested containers")
+    let holder = JSValueHolder()
+    let container = JSArrayEncodingContainer(
+      to: holder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [key]
+    )
+    object.setProperty(key.stringValue, value: holder.value)
+    return container
   }
 
   func superEncoder() -> any Encoder {
-    fatalError("superEncoder() is not implemented in JSValueEncoder")
+    fatalError("JSValueEncoder does not support superEncoder()")
   }
 
   func superEncoder(forKey key: Key) -> any Encoder {
-    return self.superEncoder()
+    fatalError("JSValueEncoder does not support superEncoder(forKey:)")
   }
 }
 
 /**
  Unkeyed container that encodes values to a JavaScript array.
+
+ Like `JSObjectEncodingContainer`, this is a `class` so it can hold the
+ non-copyable `JavaScriptArray` directly without forcing the container itself
+ to be non-copyable.
  */
-private struct JSArrayEncodingContainer: UnkeyedEncodingContainer {
-  private weak var runtime: JavaScriptRuntime?
+private final class JSArrayEncodingContainer: UnkeyedEncodingContainer {
+  private let appContext: AppContext
+  private let runtime: JavaScriptRuntime
   private let valueHolder: JSValueHolder
-  private var items: [JavaScriptValue] = []
+  private let array: JavaScriptArray
+  let codingPath: [any CodingKey]
+  var count: Int = 0
 
-  init(to valueHolder: JSValueHolder, runtime: JavaScriptRuntime) {
+  init(to valueHolder: JSValueHolder, appContext: AppContext, runtime: JavaScriptRuntime, codingPath: [any CodingKey]) {
+    let array = runtime.createArray()
+    valueHolder.value = array.asValue()
+
+    self.appContext = appContext
     self.runtime = runtime
     self.valueHolder = valueHolder
+    self.array = array
+    self.codingPath = codingPath
   }
 
-  // MARK: - UnkeyedEncodingContainer
-
-  // Unused, but required by the protocol.
-  var codingPath: [any CodingKey] = []
-  var count: Int = 0
+  func encodeNil() throws {
+    array[count] = JavaScriptValue.null
+    count += 1
+  }
 
-  mutating func encodeNil() throws {
-    items.append(JavaScriptValue.null)
+  func encode<ValueType: Encodable>(_ value: ValueType) throws {
+    let encoded = try encodeUsingDynamicType(
+      value,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [AnyCodingKey(intValue: count)]
+    )
+    array[count] = encoded
+    count += 1
   }
 
-  mutating func encode<ValueType: Encodable>(_ value: ValueType) throws {
-    guard let runtime else {
-      // Do nothing when the runtime is already deallocated
-      return
-    }
-    let encoder = JSValueEncoder(runtime: runtime)
-    try value.encode(to: encoder)
+  func nestedContainer<NestedKey: CodingKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> {
+    let holder = JSValueHolder()
+    let container = JSObjectEncodingContainer<NestedKey>(
+      to: holder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [AnyCodingKey(intValue: count)]
+    )
+    array[count] = holder.value
+    count += 1
+    return KeyedEncodingContainer(container)
+  }
 
-    items.append(encoder.value)
-    valueHolder.value = .representing(value: items, in: runtime)
+  func nestedUnkeyedContainer() -> any UnkeyedEncodingContainer {
+    let holder = JSValueHolder()
+    let container = JSArrayEncodingContainer(
+      to: holder,
+      appContext: appContext,
+      runtime: runtime,
+      codingPath: codingPath + [AnyCodingKey(intValue: count)]
+    )
+    array[count] = holder.value
+    count += 1
+    return container
   }
 
-  mutating func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> where NestedKey : CodingKey {
-    fatalError("JSValueEncoder does not support nested containers")
+  func superEncoder() -> any Encoder {
+    fatalError("JSValueEncoder does not support superEncoder()")
   }
+}
+
+// MARK: - Helpers
+
+/**
+ A coding key carrying just a string and an integer index. Used to extend
+ `codingPath` with array indices in the unkeyed container, since unkeyed
+ containers have no associated `Key` type to draw from.
+ */
+private struct AnyCodingKey: CodingKey {
+  let stringValue: String
+  let intValue: Int?
 
-  mutating func nestedUnkeyedContainer() -> any UnkeyedEncodingContainer {
-    fatalError("JSValueEncoder does not support nested containers")
+  init(stringValue: String) {
+    self.stringValue = stringValue
+    self.intValue = Int(stringValue)
   }
 
-  mutating func superEncoder() -> any Encoder {
-    fatalError("superEncoder() is not implemented in JSValueEncoder")
+  init(intValue: Int) {
+    self.stringValue = String(intValue)
+    self.intValue = intValue
   }
 }

package/ios/DevTools/CdpNetworkTypes.swift

@@ -110,7 +110,7 @@ struct CdpNetwork {
 
   struct RequestWillBeSentExtraInfoParams: EventParams {
     let requestId: RequestId
-    var associatedCookies = [String: String]()
+    var associatedCookies = [String]()
     let headers: Headers
     let connectTiming: ConnectTiming
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "56.0.6",
+  "version": "56.0.8",
   "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.0.8",
-    "expo-modules-jsi": "~56.0.3",
+    "expo-modules-jsi": "~56.0.4",
     "invariant": "^2.2.4"
   },
   "peerDependencies": {
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.2"
   },
-  "gitHead": "42013232893cb2aa71ab218e9b422d4a8476b3f0",
+  "gitHead": "51c27fce31a5b3a877a4b05d832dabf4a99db5e1",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",

package/src/polyfill/CoreModule.ts

@@ -100,9 +100,9 @@ export class SharedObject<TEventsMap extends Record<never, never>>
 }
 
 export class SharedRef<
-    TNativeRefType extends string = 'unknown',
-    TEventsMap extends EventsMap = Record<never, never>,
-  >
+  TNativeRefType extends string = 'unknown',
+  TEventsMap extends EventsMap = Record<never, never>,
+>
   extends SharedObject<TEventsMap>
   implements SharedRefType<TNativeRefType>
 {

package/src/ts-declarations/SharedRef.ts

@@ -11,9 +11,9 @@ import type { SharedObject } from './SharedObject';
  * directly to the image view from `expo-image` without any additional writes and reads from the file system.
  */
 export declare class SharedRef<
-    TNativeRefType extends string = 'unknown',
-    TEventsMap extends EventsMap = Record<never, never>,
-  >
+  TNativeRefType extends string = 'unknown',
+  TEventsMap extends EventsMap = Record<never, never>,
+>
   extends SharedObject<TEventsMap>
   implements SharedObject<TEventsMap>
 {