@granite-js/micro-frontend 2.0.0

package/README.md

@@ -0,0 +1,508 @@
+# @granite-js/micro-frontend
+
+Micro-frontend contracts for Granite React Native brownfield applications.
+
+This package is the complete micro-frontend feature boundary. It contains:
+
+- the build plugin that produces self-registering remote bundles;
+- the JavaScript runtime that loads, evaluates, and imports remote modules;
+- the Mono-Hermes native session and visibility contract;
+- the host pending component contract; and
+- the Portal primitive that attaches a mounted React subtree to an
+  `Activity`- or `UIViewController`-owned destination.
+
+`@granite-js/portal` is not a separate dependency. Portal is coupled to the
+shared-runtime session contract and is exported from this package.
+
+## Ownership model
+
+```text
+Granite brownfield host
+├── native screen lifecycle
+│   ├── session identity
+│   └── presentation visibility
+├── Brownfield Brick registry
+│   └── close the current native view
+├── one retained React Native runtime
+│   ├── evaluate remote bundle
+│   ├── keep one React tree per session
+│   └── render each tree through Portal
+└── native Portal destination
+    └── attach content by the same sessionId
+```
+
+Native screen lifecycle is the source of truth for visibility. Portal only
+owns where content is attached. A Portal host can remain attached while its
+screen is stopped or covered, so Portal attachment must not be used to infer
+presentation visibility.
+
+The session identifier joins the contracts:
+
+```text
+register native session(sessionId)
+  → openApp(sessionId, appName, scheme)
+  → <MicroFrontendSessionProvider sessionId={sessionId}>
+  → <Portal hostName={sessionId}>
+  → native Portal host named sessionId
+```
+
+## Installation
+
+```sh
+yarn add @granite-js/micro-frontend
+```
+
+The package autolinks one Android library and one iOS Pod. Its React Native
+Codegen library, `GraniteMicroFrontendRuntimeSpec`, contains both the
+`GraniteMicroFrontendRuntime` TurboModule and the `PortalView` / `PortalHostView`
+Fabric components.
+
+## Build plugin
+
+The app name comes from `granite.config.ts`. Hosts do not maintain a separate
+remote-app list.
+
+```ts
+// Remote app
+import { microFrontend } from '@granite-js/micro-frontend/plugin';
+import { defineConfig } from '@granite-js/react-native/config';
+
+export default defineConfig({
+  appName: 'cart',
+  plugins: [
+    microFrontend({
+      exposes: {
+        './App': './src/_app.tsx',
+      },
+      shared: ['react', 'react-native'],
+    }),
+  ],
+});
+```
+
+```ts
+// Host app
+import { microFrontend } from '@granite-js/micro-frontend/plugin';
+import { defineConfig } from '@granite-js/react-native/config';
+
+export default defineConfig({
+  appName: 'shared',
+  plugins: [
+    microFrontend({
+      shared: {
+        react: { eager: true },
+        'react-native': { eager: true },
+      },
+    }),
+  ],
+});
+```
+
+When evaluated, a remote bundle registers its `appName` container and exposed
+modules in the shared runtime registry.
+
+## JavaScript runtime
+
+The adapter owns bundle selection, download, integrity verification, and
+caching. It returns an absolute local bundle path.
+
+```ts
+import { createMicroFrontendRuntime } from '@granite-js/micro-frontend';
+import type { ComponentType } from 'react';
+
+const runtime = createMicroFrontendRuntime({
+  adapter: {
+    async loadBundle({ appName }) {
+      const filePath = await bundleStore.loadBundle(appName);
+      return { filePath };
+    },
+  },
+});
+
+await runtime.preloadApp('cart');
+
+const App = await runtime.importApp<{
+  readonly default: ComponentType<{ readonly scheme: string }>;
+}>('cart/App');
+```
+
+`importApp('cart/App')` performs:
+
+```text
+adapter.loadBundle({ appName: 'cart' })
+  → GraniteMicroFrontendRuntime.evaluateScript({ filePath })
+  → verify that the cart container registered itself
+  → return the cart container's ./App module
+```
+
+Concurrent preload/import calls for one app share an evaluation. A successful
+evaluation remains cached until its last native session closes. Failed
+evaluation removes the partial container so a later request can retry.
+Native `preloadApp` events invoke `preloadApp()` inside the runtime and are not
+forwarded to session listeners. `onPreloadError` is optional and lets the host
+route best-effort native preload failures to its observability provider.
+
+The public runtime API is:
+
+| API | Responsibility |
+| --- | --- |
+| `preloadApp(appName)` | Load and evaluate one app without importing an exposed module. |
+| `importApp(request)` | Ensure the app is evaluated and import `appName/exposedModule`. |
+| `evaluateScript(filePath)` | Evaluate an already-local bundle in the retained runtime. |
+| `onEvent(listener)` | Subscribe to native open, close, and visibility events. |
+
+## Session rendering
+
+The brownfield host owns the product-specific session track. Compose the Portal
+destination with `MicroFrontendSessionProvider` so native presentation state
+joins Granite's existing visibility context.
+
+```tsx
+const sessions = useMicroFrontendSessions(runtime);
+
+function SessionRoot({ session }: { readonly session: MicroFrontendSessionState }) {
+  const App = useMemo(
+    () => lazy(() => runtime.importApp(`${session.appName}/App`)),
+    [session.appName]
+  );
+
+  return (
+    <Portal hostName={session.sessionId}>
+      <MicroFrontendSessionProvider
+        sessionId={session.sessionId}
+        presentationVisibility={session.isVisible}
+      >
+        <App scheme={session.scheme} />
+      </MicroFrontendSessionProvider>
+    </Portal>
+  );
+}
+```
+
+`useMicroFrontendSessions(runtime)` owns the fixed React subscription and folds
+native open, close, and visibility events into session descriptors. The host
+continues to own module selection and the rendered Portal tree.
+
+The provider exposes the native session identity and combines
+`presentationVisibility` with Granite's existing `VisibilityChangedProvider`.
+Remote apps continue to read the final app, navigation, and native-session
+visibility through `useVisibility()`.
+
+Remote apps use Granite's `useVisibility()` for visibility and
+`closeView()` to close the current brownfield view. They do not receive
+`sessionId` as an application prop.
+
+## Host pending component
+
+Remote apps register a route-level pending component with this package's
+`createRoute` wrapper.
+
+```tsx
+import { createRoute, hidePendingHostComponent } from '@granite-js/micro-frontend';
+import { useEffect } from 'react';
+
+export const Route = createRoute('/products/:productId', {
+  component: ProductPage,
+  validateParams: parseProductParams,
+  hostPendingComponent: ({ thumbnailUrl }) => (
+    <ProductPendingComponent thumbnailUrl={thumbnailUrl} />
+  ),
+});
+
+function ProductPage() {
+  useEffect(() => {
+    hidePendingHostComponent();
+  }, []);
+
+  return <Product />;
+}
+```
+
+The host resolves `PendingHostComponent` from the incoming scheme. The route
+registry and hidden state live on the JavaScript global object, so separately
+bundled host and remote package instances share the same state.
+
+## Native event contract
+
+The Codegen TurboModule is named `GraniteMicroFrontendRuntime`.
+
+```ts
+interface Spec extends TurboModule {
+  evaluateScript(request: { readonly filePath: string }): Promise<void>;
+  startEventDelivery(): void;
+  readonly onEvent: CodegenTypes.EventEmitter<NativeMicroFrontendRuntimeEvent>;
+}
+```
+
+These methods are implemented by this package. A brownfield application does
+not implement another TurboModule. Request objects are used so optional fields
+can be added without changing positional arguments. `startEventDelivery()`
+is internal runtime plumbing.
+
+Native emits the following events:
+
+| Event | Required params | Meaning |
+| --- | --- | --- |
+| `preloadApp` | `appName` | Warm an app. |
+| `openApp` | `sessionId`, `appName`, `scheme` | Create the session's React tree. |
+| `sessionVisibilityChanged` | `sessionId`, `isVisible` | Update presentation visibility from native lifecycle. |
+| `closeApp` | `sessionId` | Unmount the tree and release the app when its last session closes. |
+
+Events emitted before JavaScript subscribes are queued. Event delivery starts
+after the runtime installs its first listener.
+
+## Brownfield integration checklist
+
+The brownfield application must:
+
+1. retain one React Native runtime and the controller surface that renders the
+   session track;
+2. create a unique `sessionId` for every native destination screen;
+3. resolve `appName` and the incoming `scheme` at the native navigation
+   boundary;
+4. bind native screen lifecycle to the session APIs below;
+5. install a Portal destination with the same `sessionId`;
+6. provide `adapter.loadBundle()` and return an absolute verified bundle path;
+7. keep the React tree mounted until native teardown emits `closeApp`; and
+8. keep Granite's base brownfield view APIs, such as scheme resolution and
+   closing the current Granite view, in the Granite host integration. They are
+   not duplicated by this package.
+
+The container-owned Brownfield Brick registry defines how the current native
+view closes. JavaScript uses Granite's `closeView()` command. The session
+lifecycle remains separate: native emits `closeApp(sessionId)` only when the
+container actually tears down so JavaScript can unmount its React tree.
+
+## Android native API
+
+All public Android APIs live in `run.granite.microfrontend`, except the Portal
+destination views in `com.teleport.host`.
+
+### Session APIs
+
+| API | Lifetime / behavior |
+| --- | --- |
+| `ActivitySessionBinding.bind(activity, sessionId, appName, scheme)` | Convenience binding for an `Activity`. Emits open, derives visibility from start/stop, and emits close on destroy. Bindings are keyed by `sessionId`, so a destroy caused by a configuration change keeps the session open and the next `bind()` with the same id rebinds the recreated instance instead of opening a second session. Use a `sessionId` that identifies the destination, not the Activity instance. Retain it for the Activity lifetime. |
+| `GraniteMicroFrontendRuntimeHost.registerSession(sessionId)` | Register a custom native container and return a `GraniteMicroFrontendSessionRegistration`. `sessionId` must be unique for every live destination; reuse only after the previous registration is closed/invalidated. |
+| `GraniteMicroFrontendSessionRegistration.openApp(appName, scheme)` | Emit `openApp` once. |
+| `GraniteMicroFrontendSessionRegistration.setVisible(isVisible)` | Emit a visibility event only when the value changes. |
+| `GraniteMicroFrontendSessionRegistration.closeApp()` | Emit `closeApp` once after open. |
+| `GraniteMicroFrontendSessionRegistration.close()` | Unregister the native session. Call after `closeApp()`. |
+| `GraniteMicroFrontendRuntimeHost.emitPreloadApp(appName)` | Fire-and-forget preload. |
+
+### Portal destination APIs
+
+| API | Lifetime / behavior |
+| --- | --- |
+| `PortalHostView.setName(name)` | Register/unregister the destination name. Use `sessionId`. |
+| `PortalHostView.cleanup()` | Permanently unregister the destination during teardown. |
+| `PortalReactRootView(context, reactHost, surfaceId, moduleName)` | Detached Fabric root that forwards touch/pointer events through the retained `ReactHost`; it does not start another runtime or surface. |
+
+`PortalHostView` also re-registers on window attachment and temporarily
+unregisters while detached. `nextInsertionIndexForChildAt()` is renderer
+plumbing, not an application integration API.
+
+#### Props the Portal components do not apply
+
+`Portal` and the Portal host component are renderer plumbing, not styleable
+views. Their TypeScript props extend `ViewProps` because React Native's codegen
+only accepts `ViewProps` as a base, so the type advertises more than the native
+managers apply. The following are accepted by the type checker and silently
+ignored on Android: `pointerEvents` (the native manager pins it to `box-none`
+so touches reach the portalled tree), `hitSlop`, `focusable`, `accessible`,
+`nativeBackgroundAndroid`, `nativeForegroundAndroid`, `borderStyle`,
+`overflow`, `backfaceVisibility`, `collapsable`, `collapsableChildren`,
+`needsOffscreenAlphaCompositing`, `background*` shorthands, `hasTVPreferredFocus`
+and the `nextFocus*` family.
+
+Wrap the Portal in your own `<View>` when you need any of these.
+
+### Activity example
+
+```kotlin
+import android.os.Bundle
+import android.widget.FrameLayout
+import androidx.appcompat.app.AppCompatActivity
+import com.facebook.react.ReactHost
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ThemedReactContext
+import com.teleport.host.PortalHostView
+import com.teleport.host.PortalReactRootView
+import run.granite.microfrontend.ActivitySessionBinding
+
+class CartActivity : AppCompatActivity() {
+  // The session id identifies the destination, not the Activity instance. A value generated per
+  // instance changes on every configuration change, so rotation would close and reopen the session
+  // and remount the React tree. Derive it from what the caller navigated to.
+  private val sessionId: String
+    get() = requireNotNull(intent.data?.host) {
+      "CartActivity requires the destination name as the URI host"
+    }
+
+  private lateinit var sessionBinding: ActivitySessionBinding
+  private var portalHostView: PortalHostView? = null
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val scheme = requireNotNull(intent.data).toString()
+
+    sessionBinding = ActivitySessionBinding.bind(
+      activity = this,
+      sessionId = sessionId,
+      appName = "cart",
+      scheme = scheme,
+    )
+  }
+
+  fun installPortalHost(
+    reactContext: ReactApplicationContext,
+    reactHost: ReactHost,
+    controllerSurfaceId: Int,
+    controllerModuleName: String,
+  ) {
+    val themedContext = ThemedReactContext(
+      reactContext,
+      this,
+      controllerModuleName,
+      controllerSurfaceId,
+    )
+    val rootView = PortalReactRootView(
+      themedContext,
+      reactHost,
+      controllerSurfaceId,
+      controllerModuleName,
+    )
+    val hostView = PortalHostView(themedContext).apply { setName(sessionId) }
+
+    rootView.addView(
+      hostView,
+      FrameLayout.LayoutParams(
+        FrameLayout.LayoutParams.MATCH_PARENT,
+        FrameLayout.LayoutParams.MATCH_PARENT,
+      ),
+    )
+    portalHostView = hostView
+    setContentView(rootView)
+  }
+
+  override fun onDestroy() {
+    portalHostView?.cleanup()
+    portalHostView = null
+    super.onDestroy()
+  }
+}
+```
+
+Install the Portal host only after the retained `ReactHost` has an active
+`ReactApplicationContext`. The brownfield runtime owner still forwards normal
+resume, pause, destroy, and back events to its retained `ReactHost`.
+
+Custom screen containers use `registerSession()` and drive `openApp()`,
+`setVisible()`, `closeApp()`, and `close()` from their own lifecycle.
+
+## iOS native API
+
+Import public APIs from `GraniteMicroFrontendRuntime`.
+
+```objc
+#import <GraniteMicroFrontendRuntime/GraniteMicroFrontendRuntimeHost.h>
+#import <GraniteMicroFrontendRuntime/PortalHostContainerView.h>
+```
+
+### Session APIs
+
+| API | Lifetime / behavior |
+| --- | --- |
+| `+[GraniteMicroFrontendViewControllerSessionBinding bindViewController:sessionId:appName:scheme:]` | Convenience binding for a `UIViewController`. Emits open and derives visibility from `viewWillAppear` / `viewWillDisappear` combined with app foreground and background transitions. Returns `nil` if `sessionId` is already registered. Retain until teardown. |
+| `-[GraniteMicroFrontendViewControllerSessionBinding invalidate]` | Emit close and detach lifecycle observation. |
+| `+[GraniteMicroFrontendRuntimeHost registerSession:]` | Register a custom container and return a session registration, or `nil` if `sessionId` is already registered. Use a unique id per destination and call `invalidate` before reuse. |
+| `-[GraniteMicroFrontendSessionRegistration openAppWithAppName:scheme:]` | Emit `openApp` once. |
+| `-[GraniteMicroFrontendSessionRegistration setVisible:]` | Emit visibility only when it changes. |
+| `-[GraniteMicroFrontendSessionRegistration closeApp]` | Emit `closeApp` once after open. |
+| `-[GraniteMicroFrontendSessionRegistration invalidate]` | Unregister the session. Call after `closeApp`. |
+| `+[GraniteMicroFrontendRuntimeHost emitPreloadApp:]` | Fire-and-forget preload. |
+
+### Portal destination APIs
+
+| API | Lifetime / behavior |
+| --- | --- |
+| `-initWithFrame:` | Create and immediately activate a UIKit-owned Portal destination after React has booted. |
+| `-initWithFrame:deferredActivation:` | Create before React boot without reading React feature flags. |
+| `-setName:` | Register/unregister the destination name. Use `sessionId`. |
+| `-activateIfNeeded` | Create the Fabric host, attach its touch handler, and apply the pending name. Main thread only, after React boot. |
+| `isActivated` | Whether the underlying Fabric host exists. |
+| `hasAttachedContent` | Whether teleported content is currently attached. This is readiness, not presentation visibility. |
+| `onContentDidAttach` / `onContentDidDetach` | Main-thread readiness callbacks for the first attach and last detach. |
+| `-invalidate` | Unregister the host and clear callbacks during teardown. |
+
+### UIViewController example
+
+```swift
+import GraniteMicroFrontendRuntime
+import UIKit
+
+final class CartViewController: UIViewController {
+  /// Create a new id for every push/present. Reusing an id before the previous
+  /// binding is invalidated fails registration.
+  private let sessionId = UUID().uuidString
+  private var sessionBinding: GraniteMicroFrontendViewControllerSessionBinding?
+  private var portalHostView: PortalHostContainerView!
+
+  override func viewDidLoad() {
+    super.viewDidLoad()
+
+    portalHostView = PortalHostContainerView(
+      frame: view.bounds,
+      deferredActivation: true
+    )
+    portalHostView.setName(sessionId)
+    view.addSubview(portalHostView)
+
+    sessionBinding = GraniteMicroFrontendViewControllerSessionBinding.bindViewController(
+      self,
+      sessionId: sessionId,
+      appName: "cart",
+      scheme: "granite://cart/products/1"
+    )
+  }
+
+  func reactRuntimeDidStart() {
+    portalHostView.activateIfNeeded()
+  }
+
+  deinit {
+    sessionBinding?.invalidate()
+    portalHostView?.invalidate()
+  }
+}
+```
+
+Create, activate, and invalidate these objects on the main thread. Call
+`invalidate` during teardown so the binding and Portal destination are released
+with the controller.
+
+## Portal primitive and example
+
+`Portal` remains public for a Portal-only integration or test fixture:
+
+```tsx
+import { Portal } from '@granite-js/micro-frontend';
+
+<Portal hostName="store">
+  <StoreNavigationContainer />
+</Portal>;
+```
+
+The React subtree keeps the same owner, context, and state while its native
+views move to the named destination. Host names are application data; a
+generic native destination should read the requested name at runtime.
+
+See [examples/portal/README.md](examples/portal/README.md) for the retained
+Portal-only cross-Activity / UIViewController example.
+
+## License and credit
+
+Apache-2.0. The Portal implementation is based on
+[react-native-teleport](https://github.com/kirillzyusko/react-native-teleport)
+by Kiryl Ziusko; see [NOTICE](NOTICE) and
+[LICENSE.react-native-teleport](LICENSE.react-native-teleport).

package/android/CMakeLists.txt

@@ -0,0 +1,34 @@
+cmake_minimum_required(VERSION 3.13)
+project(granite-micro-frontend)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# This file is the module's own externalNativeBuild entry point and builds only the library that
+# ships inside the AAR. The codegen target lives in src/main/jni/CMakeLists.txt, which autolinking
+# builds inside the consuming app.
+
+add_library(
+  granite-micro-frontend
+  SHARED
+  src/main/cpp/BundleEvaluator.cpp
+  src/main/cpp/FileReader.cpp
+  src/main/cpp/onLoad.cpp
+)
+
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+
+target_include_directories(
+  granite-micro-frontend
+  PRIVATE
+  src/main/cpp
+)
+
+target_link_libraries(
+  granite-micro-frontend
+  android
+  fbjni::fbjni
+  ReactAndroid::jsi
+  ReactAndroid::reactnative
+)

package/android/build.gradle

@@ -0,0 +1,74 @@
+buildscript {
+  ext.safeExtGet = { name, fallback ->
+    rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', project.properties['GraniteMicroFrontendRuntime_kotlinVersion'])}"
+  }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'com.facebook.react'
+
+def getIntegerProperty(name) {
+  return safeExtGet(name, project.properties["GraniteMicroFrontendRuntime_${name}"]).toInteger()
+}
+
+android {
+  namespace 'run.granite.microfrontend'
+  compileSdkVersion getIntegerProperty('compileSdkVersion')
+
+  defaultConfig {
+    minSdkVersion getIntegerProperty('minSdkVersion')
+    targetSdkVersion getIntegerProperty('targetSdkVersion')
+
+    externalNativeBuild {
+      cmake {
+        // ANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES is what aligns the AAR's .so to a 16 KB page
+        // boundary. React Native passes it for the app build; a library build has to pass it
+        // itself, otherwise the .so this module ships stays 4 KB aligned.
+        arguments '-DANDROID_STL=c++_shared', '-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON'
+      }
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  externalNativeBuild {
+    cmake {
+      path 'CMakeLists.txt'
+    }
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = '17'
+  }
+
+  testOptions {
+    unitTests.returnDefaultValues = true
+  }
+}
+
+dependencies {
+  implementation 'com.facebook.react:react-android'
+  implementation 'com.facebook.fbjni:fbjni:0.7.0'
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet('kotlinVersion', project.properties['GraniteMicroFrontendRuntime_kotlinVersion'])}"
+  testImplementation 'junit:junit:4.13.2'
+  testImplementation 'org.mockito:mockito-core:5.14.2'
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+GraniteMicroFrontendRuntime_kotlinVersion=2.0.21
+GraniteMicroFrontendRuntime_compileSdkVersion=35
+GraniteMicroFrontendRuntime_minSdkVersion=24
+GraniteMicroFrontendRuntime_targetSdkVersion=35

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/cpp/BundleEvaluator.cpp

@@ -0,0 +1,64 @@
+#include "BundleEvaluator.h"
+#include "FileReader.h"
+
+#include <jsi/jsi.h>
+
+namespace granite::microfrontend {
+
+using facebook::jni::JString;
+using facebook::jni::alias_ref;
+using facebook::jsi::Runtime;
+using facebook::jsi::StringBuffer;
+
+void BundleEvaluator::registerNatives() {
+  registerHybrid(
+      {makeNativeMethod("evaluateFileSync", BundleEvaluator::evaluateFileSync)});
+}
+
+void BundleEvaluator::evaluateFileSync(
+    alias_ref<jhybridobject>,
+    jlong runtimePointer,
+    alias_ref<JString> filePath,
+    alias_ref<JString> sourceUrl) {
+  if (runtimePointer == 0) {
+    facebook::jni::throwNewJavaException(
+        "java/lang/IllegalStateException", "JavaScript runtime is unavailable");
+    return;
+  }
+
+  const std::string path = filePath->toStdString();
+  std::string source;
+  try {
+    source = io::readFileToMemory(path);
+  } catch (const io::FileReaderError &error) {
+    switch (error.kind()) {
+      case io::FileReaderErrorKind::NotFound:
+        facebook::jni::throwNewJavaException(
+            "java/io/FileNotFoundException", "%s", error.what());
+        break;
+      case io::FileReaderErrorKind::StatFailed:
+      case io::FileReaderErrorKind::ReadFailed:
+        facebook::jni::throwNewJavaException(
+            "java/io/IOException", "%s", error.what());
+        break;
+      case io::FileReaderErrorKind::AllocationFailed:
+        facebook::jni::throwNewJavaException(
+            "java/lang/OutOfMemoryError", "%s", error.what());
+        break;
+    }
+    return;
+  }
+
+  if (source.empty()) {
+    facebook::jni::throwNewJavaException(
+        "java/io/IOException", "Bundle file is empty: %s", path.c_str());
+    return;
+  }
+
+  auto *runtime = reinterpret_cast<Runtime *>(runtimePointer);
+  runtime->evaluateJavaScript(
+      std::make_shared<StringBuffer>(std::move(source)),
+      sourceUrl->toStdString());
+}
+
+} // namespace granite::microfrontend