feat: add Expo module isolation via scoped AppContext per sandbox origin

Auto-detects expo-modules-core at build time so vanilla RN projects are unaffected:
- iOS (podspec): File.exist? check sets RNS_HAS_EXPO_MODULES=1 via pod_target_xcconfig
  and pulls in ios/Expo/**  sources + expo-modules-core/expo dependencies only when present
- Android (build.gradle): rootProject.file("node_modules/expo-modules-core").exists()
  gates the src/expo/java source set, expo-modules-core dependency, and HAS_EXPO_MODULES
  BuildConfig field

iOS isolation (gated by #if RNS_HAS_EXPO_MODULES):
- SandboxExpoFactory.mm: creates ExpoReactNativeFactory instead of RCTReactNativeFactory,
  enabling Expo module registration inside the sandbox RCTHost
- SandboxAppContextBridge.swift: Swift bridge that creates EXAppContext with a scoped
  AppContextConfig (documentDirectory/cacheDirectory under SandboxData/<sanitized-origin>/)
- SandboxReactNativeDelegate.mm: injects the scoped EXAppContext via
  ExpoBridgeModule.initWithAppContext: in getModuleInstanceFromClass: so Expo modules
  (FileSystem, SecureStore, etc.) read/write origin-namespaced directories

Android isolation:
- SandboxContextWrapper already scopes getFilesDir/getCacheDir/getSharedPreferences to the
  origin; AppContext receives this wrapped context so Expo modules are automatically scoped
- ExpoIntegration.kt provides a ModuleRegistryAdapter with the host project's Expo packages

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: CAMOBAP

packages/react-native-sandbox/React-Sandbox.podspec

@@ -2,6 +2,8 @@ require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
+has_expo = File.exist?(File.join(__dir__, "../../node_modules/expo-modules-core"))
+
 header_search_paths = [
   "\"$(PODS_TARGET_SRCROOT)/ReactCommon\"",
   "\"$(PODS_ROOT)/Headers/Private/React-Core\"",
@@ -18,12 +20,20 @@ Pod::Spec.new do |s|
   s.authors      = { "Alex Babrykovich" => "aliaksandr.babrykovich@callstack.com" }
   s.platforms    = { :ios => "12.4" }
   s.source       = { :git => "https://github.com/callstackincubator/react-native-sandbox.git", :tag => "#{s.version}" }
-  s.source_files = ["ios/**/*.{h,m,mm,cpp,swift}", "cxx/**/*.{h,cpp}"]
+  s.source_files = ["ios/*.{h,m,mm,cpp}", "cxx/**/*.{h,cpp}"]
   install_modules_dependencies(s)
   s.dependency "fmt"
-  s.pod_target_xcconfig    = {
+
+  expo_xcconfig = {}
+  if has_expo
+    s.source_files += ["ios/Expo/**/*.{h,m,mm,swift}"]
+    s.dependency "expo-modules-core"
+    s.dependency "expo"
+    expo_xcconfig = { "OTHER_CPLUSPLUSFLAGS" => "$(inherited) -DRNS_HAS_EXPO_MODULES=1" }
+  end
+
+  s.pod_target_xcconfig = {
     "HEADER_SEARCH_PATHS" => header_search_paths + ["\"$(PODS_TARGET_SRCROOT)/cxx\""],
-    # "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
-  }
+  }.merge(expo_xcconfig)
 end

packages/react-native-sandbox/android/build.gradle

@@ -16,6 +16,8 @@ apply plugin: "com.android.library"
 apply plugin: "org.jetbrains.kotlin.android"
 apply plugin: "com.facebook.react"
 
+def hasExpo = rootProject.file("node_modules/expo-modules-core").exists()
+
 def safeExtGet(prop, fallback) {
   rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
@@ -27,6 +29,7 @@ android {
   defaultConfig {
     minSdkVersion safeExtGet("minSdkVersion", 24)
     targetSdkVersion safeExtGet("targetSdkVersion", 35)
+    buildConfigField "boolean", "HAS_EXPO_MODULES", "${hasExpo}"
 
     externalNativeBuild {
       cmake {
@@ -45,6 +48,7 @@ android {
   sourceSets {
     main {
       java.srcDirs += ["src/main/java"]
+      if (hasExpo) java.srcDirs += ["src/expo/java"]
     }
   }
 
@@ -59,6 +63,7 @@ android {
 
   buildFeatures {
     prefab true
+    buildConfig true
   }
 }
 
@@ -69,4 +74,7 @@ repositories {
 
 dependencies {
   implementation "com.facebook.react:react-android:+"
+  if (hasExpo) {
+    implementation "expo.modules:expo-modules-core:+"
+  }
 }

packages/react-native-sandbox/android/src/expo/java/io/callstack/rnsandbox/ExpoIntegration.kt

@@ -0,0 +1,29 @@
+package io.callstack.rnsandbox
+
+import com.facebook.react.ReactPackage
+import expo.modules.adapters.react.ModuleRegistryAdapter
+import expo.modules.adapters.react.ReactAdapterPackage
+import expo.modules.adapters.react.ReactModuleRegistryProvider
+import expo.modules.kotlin.ExpoModulesHelper
+
+/**
+ * Wires Expo modules into a sandbox React Native host.
+ *
+ * Each sandbox already wraps its ReactApplicationContext with SandboxContextWrapper,
+ * which overrides getFilesDir(), getCacheDir(), and getSharedPreferences() to return
+ * origin-namespaced paths. Since Expo's AppContext receives this wrapped context, all
+ * Expo modules (FileSystem, SecureStore, etc.) automatically operate in scoped
+ * directories without additional AppContext configuration.
+ */
+internal object ExpoIntegration {
+    /**
+     * Returns the ReactPackage instances required to expose Expo modules inside a
+     * sandbox. Include the result in the sandbox's package list when
+     * BuildConfig.HAS_EXPO_MODULES is true.
+     */
+    fun createPackages(): List<ReactPackage> {
+        val registryProvider = ReactModuleRegistryProvider(listOf(ReactAdapterPackage()), null)
+        val modulesProvider = ExpoModulesHelper.modulesProvider
+        return listOf(ModuleRegistryAdapter(registryProvider, modulesProvider))
+    }
+}

packages/react-native-sandbox/ios/Expo/SandboxAppContextBridge.swift

@@ -0,0 +1,33 @@
+// Copyright 2025-present Callstack. All rights reserved.
+
+import ExpoModulesCore
+import Foundation
+
+/// Bridges Swift-only Expo APIs to ObjC so the sandbox can create a scoped
+/// EXAppContext per origin without exposing Swift value types across the boundary.
+@objc(SandboxAppContextBridge)
+public class SandboxAppContextBridge: NSObject {
+  /// Returns an EXAppContext whose document and cache directories are namespaced
+  /// to the given sandbox origin. Callers own the returned object.
+  @objc public static func createScopedAppContext(forOrigin origin: String) -> EXAppContext {
+    let sanitized =
+      origin
+      .replacingOccurrences(of: "/", with: "-")
+      .replacingOccurrences(of: "@", with: "-")
+      .replacingOccurrences(of: ":", with: "-")
+
+    let fileManager = FileManager.default
+    let docs = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first
+    let caches = fileManager.urls(for: .cachesDirectory, in: .userDomainMask).first
+
+    let docDir = docs?.appendingPathComponent("SandboxData/\(sanitized)")
+    let cacheDir = caches?.appendingPathComponent("SandboxData/\(sanitized)")
+
+    let config = AppContextConfig(
+      documentDirectory: docDir,
+      cacheDirectory: cacheDir,
+      appGroups: nil
+    )
+    return AppContext(config: config)
+  }
+}

packages/react-native-sandbox/ios/Expo/SandboxExpoFactory.h

@@ -0,0 +1,18 @@
+// Copyright 2025-present Callstack. All rights reserved.
+//
+// Thin helper so Core ObjC++ files can create an ExpoReactNativeFactory without
+// directly importing the Expo Swift-generated header (which is only available
+// when expo-modules-core is present and RNS_HAS_EXPO_MODULES=1).
+
+#import <React-RCTAppDelegate/RCTReactNativeFactory.h>
+
+@protocol RCTReactNativeFactoryDelegate;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Returns a new ExpoReactNativeFactory configured with the given delegate.
+/// Core files use this function behind a #if RNS_HAS_EXPO_MODULES guard so the
+/// Expo pod dependency is only pulled in when expo-modules-core is present.
+RCTReactNativeFactory *SandboxCreateExpoFactory(id<RCTReactNativeFactoryDelegate> delegate);
+
+NS_ASSUME_NONNULL_END

packages/react-native-sandbox/ios/Expo/SandboxExpoFactory.mm

@@ -0,0 +1,18 @@
+// Copyright 2025-present Callstack. All rights reserved.
+
+#import "SandboxExpoFactory.h"
+
+// ExpoReactNativeFactory is a Swift class in the Expo pod. Its ObjC interface is
+// generated during build and available via the Swift compatibility header.
+#if __has_include(<Expo/Expo-Swift.h>)
+#import <Expo/Expo-Swift.h>
+#elif __has_include(<Expo/Swift.h>)
+#import <Expo/Swift.h>
+#else
+#import "Expo-Swift.h"
+#endif
+
+RCTReactNativeFactory *SandboxCreateExpoFactory(id<RCTReactNativeFactoryDelegate> delegate)
+{
+  return [[ExpoReactNativeFactory alloc] initWithDelegate:delegate];
+}

packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm

@@ -35,6 +35,15 @@
 #include "SandboxRegistry.h"
 #import "StubTurboModuleCxx.h"
 
+#if RNS_HAS_EXPO_MODULES
+#import <ExpoModulesCore/ExpoBridgeModule.h>
+#if __has_include(<React-Sandbox/React-Sandbox-Swift.h>)
+#import <React-Sandbox/React-Sandbox-Swift.h>
+#else
+#import "React-Sandbox-Swift.h"
+#endif
+#endif
+
 namespace jsi = facebook::jsi;
 namespace TurboModuleConvertUtils = facebook::react::TurboModuleConvertUtils;
 using namespace facebook::react;
@@ -655,6 +664,20 @@ - (Class)getModuleClassFromName:(const char *)name
     }
   }
 
+#if RNS_HAS_EXPO_MODULES
+  // Scope the Expo modules bridge to this sandbox's origin. Each sandbox already
+  // gets its own ExpoBridgeModule instance (via its own RCTHost), but the default
+  // init creates an un-scoped EXAppContext. Inject a scoped one so Expo modules
+  // (file system, secure store, etc.) write to origin-namespaced directories.
+  if ([moduleClass isSubclassOfClass:[ExpoBridgeModule class]]) {
+    NSString *originNS = [NSString stringWithUTF8String:_origin.c_str()];
+    EXAppContext *ctx = [SandboxAppContextBridge createScopedAppContextForOrigin:originNS];
+    ExpoBridgeModule *bridgeModule = [[moduleClass alloc] initWithAppContext:ctx];
+    _substitutedModuleInstances[moduleName] = bridgeModule;
+    return (id<RCTTurboModule>)bridgeModule;
+  }
+#endif
+
   if (!isSubstitutionTarget) {
     return nullptr;
   }

packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm

@@ -13,6 +13,10 @@
 #import <ReactCommon/RCTHost.h>
 
 #import "SandboxReactNativeDelegate.h"
+
+#if RNS_HAS_EXPO_MODULES
+#import "SandboxExpoFactory.h"
+#endif
 #import <objc/runtime.h>
 
 #include "SandboxRegistry.h"
@@ -225,7 +229,7 @@ - (void)scheduleReactViewLoad
   self.didScheduleLoad = YES;
 
   dispatch_async(dispatch_get_main_queue(), ^{
-      [self loadReactNativeView];
+    [self loadReactNativeView];
     self.didScheduleLoad = NO;
   });
 }
@@ -345,7 +349,11 @@ - (void)acquireFactory
     }
   }
 
+#if RNS_HAS_EXPO_MODULES
+  self.reactNativeFactory = SandboxCreateExpoFactory(self.reactNativeDelegate);
+#else
   self.reactNativeFactory = [[RCTReactNativeFactory alloc] initWithDelegate:self.reactNativeDelegate];
+#endif
 
   if (origin.length > 0) {
     SharedFactory *shared = [SharedFactory new];