@lynxship/expo 0.1.6 → 0.1.8

package/README.md

@@ -19,9 +19,10 @@ npx pod-install
 ```
 
 `@lynxship/expo` uses the `expo-modules-core` implementation supplied by the
-installed Expo SDK. The package keeps it as a development dependency for its
-own native-module build, so installing `@lynxship/expo` does not require a
-second manual native dependency in the application.
+installed Expo SDK. It is declared as a peer dependency so Expo Doctor can
+validate the application explicitly; `npx expo install @lynxship/expo` should
+select the SDK-compatible version. The workspace keeps a matching development
+dependency for its own native-module build.
 
 When the project uses a static `app.json` or `app.config.json`, the Expo CLI
 automatically adds `@lynxship/expo` to `expo.plugins` during `npx expo install`.
@@ -43,6 +44,12 @@ options are needed, add the config plugin manually:
           "projectId": "00000000-0000-4000-8000-000000000000",
           "channel": "production",
           "runtimeVersion": "lynx-runtime-2026-01",
+          "notifications": {
+            "enabled": true,
+            "enableBackgroundRemoteNotifications": true,
+            "communicationNotifications": true,
+            "android": { "defaultChannel": "default" }
+          },
           "publicKeys": {
             "release-key-1": "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----"
           },
@@ -90,6 +97,32 @@ you intentionally operate a pinned native compatibility lane; do not put
 `latest` in a production lockfile without reviewing the resulting native
 build.
 
+## Optional push notifications
+
+When an Expo app also uses `@lynxship/notifications/expo`, set
+`notifications.enabled` to `true` in this plugin. LynxShip delegates the
+native permission, FCM/APNs token acquisition and build-time configuration to
+the official `expo-notifications` package, then the JavaScript adapter sends
+the token to the authenticated backend. Install the SDK-selected native
+package first:
+
+```bash
+npx expo install expo-notifications expo-constants
+```
+
+The app must call `LynxShipNotifications.register(...)` with its authenticated
+user/project identity and HTTPS registration endpoint. This is intentionally
+not guessed by the plugin: app identity and backend authorization are
+application data. FCM/APNs credentials also remain in EAS/CI secrets.
+
+For message or presence notifications with profile images, pass an HTTPS
+`imageUrl` from the backend payload. Android can render the image directly
+through FCM. iOS requires a separate Notification Service Extension target;
+use the template published by `@lynxship/notifications` and add it to the Expo
+iOS project before an EAS build. The extension is a separately signed native
+target, so it cannot be created safely by the JavaScript `LynxView` component
+at runtime.
+
 ## Use the view
 
 ```tsx
@@ -101,12 +134,47 @@ export function LynxScreen() {
       style={{ flex: 1 }}
       bundle="main.lynx.bundle"
       initialData="{}"
+      globalProps={{ theme: "dark" }}
+      autoGlobalProps
       reloadOnUpdate
     />
   );
 }
 ```
 
+`globalProps` is passed to `lynx.__globalProps` during the native template
+load. It can also be changed without remounting the React Native screen. The
+native ref exposes the same host controls on Android and iOS:
+
+```tsx
+const viewRef = useRef<LynxViewRef>(null);
+
+viewRef.current?.updateData('{"screen":"inbox"}');
+viewRef.current?.updateGlobalProps({ theme: "light" });
+viewRef.current?.updateGlobalPropsByIncrement({ unreadCount: 3 });
+viewRef.current?.sendGlobalEvent("accountChanged", [{ id: "user-1" }]);
+await viewRef.current?.reload();
+```
+
+`updateData` uses Lynx's official host-data update API and accepts a JSON
+string up to 8 MiB without remounting the view. Its optional second argument
+selects a registered Lynx data processor. `show`, `hide` and
+`updateViewport({ width, height })` are also available.
+`updateGlobalPropsByIncrement` applies only the supplied keys and is useful for
+small host-state changes; `updateGlobalProps` remains the full replacement API.
+The ref also exposes `getContainerId()`, `getLoadState()` and
+`isLoadSuccess()`, matching the native container state contract without
+requiring a React remount.
+The viewport is updated automatically from the native view layout, so the
+usual `style={{ flex: 1 }}` remains the recommended layout. The native view
+owns the Lynx lifecycle and is destroyed when Expo releases the view; this
+prevents an old page/runtime from surviving React reconciliation.
+
+The view also exposes lifecycle events that can drive application-owned UI:
+`onLoadStart`, `onResourceFetchStart`, `onLoadSuccess`, `onReady` (first screen), `onError`, `onUpdate` (OTA or non-remounting data update),
+`onShow` and `onHide`. The events are notifications only; they do not replace
+the native permission, navigation or OTA policy owned by the host.
+
 The native module initializes Lynx, creates the official `LynxView`, and
 provides a template provider. The provider first reads the verified active OTA
 asset and falls back to the embedded bundle. An OTA release is accepted only
@@ -157,8 +225,13 @@ the provider is the integration point for the LynxShip OTA cache.
 
 References:
 
-- [Lynx integration with existing apps](https://lynxjs.org/3.8/guide/start/integrate-with-existing-apps.html)
+- [Lynx/Rspeedy existing-app integration](https://lynxjs.org/next/rspeedy/start/integrate-with-existing-apps)
+- [Lynx native `LynxView` API](https://lynxjs.org/next/api/lynx-native-api/lynx-view/lynx-view.html)
+- [Lynx global props](https://lynxjs.org/next/api/lynx-api/lynx/lynx-global-props.html)
+- [Lynx global events](https://lynxjs.org/next/api/lynx-native-api/lynx-view/send-global-event.html)
+- [Lynx native viewport API](https://lynxjs.org/next/api/lynx-native-api/lynx-view/update-viewport.html)
 - [Expo native view modules](https://docs.expo.dev/modules/native-view-tutorial/)
+- [Expo view refs and async functions](https://docs.expo.dev/modules/module-api/)
 - [Expo module configuration](https://docs.expo.dev/modules/module-config/)
 - [LynxShip OTA security and compatibility](../../docs/compatibility.md)
 

package/android/build.gradle

@@ -42,6 +42,7 @@ android {
 
 dependencies {
     implementation "org.lynxsdk.lynx:lynx:${lynxVersion}"
+    implementation "androidx.annotation:annotation:1.10.0"
     implementation "org.lynxsdk.lynx:lynx-jssdk:${lynxVersion}"
     implementation "org.lynxsdk.lynx:lynx-trace:${lynxVersion}"
     implementation "org.lynxsdk.lynx:primjs:${lynxVersion}"

package/android/src/main/java/com/lynxship/expo/LynxShipExpoModule.kt

@@ -8,14 +8,22 @@ class LynxShipExpoModule : Module() {
         Name("LynxShip")
 
         View(LynxShipExpoView::class) {
-            Events("onReady", "onError", "onUpdate")
+            Events("onReady", "onLoadStart", "onResourceFetchStart", "onLoadSuccess", "onError", "onUpdate", "onShow", "onHide")
 
             Prop("bundle") { view: LynxShipExpoView, value: String? ->
-                view.bundleName = value ?: "main.lynx.bundle"
+                view.setBundleName(value ?: "main.lynx.bundle")
             }
 
             Prop("initialData") { view: LynxShipExpoView, value: String? ->
-                view.initialData = value ?: ""
+                view.setInitialData(value ?: "")
+            }
+
+            Prop("globalProps") { view: LynxShipExpoView, value: Map<String, Any?>? ->
+                view.updateGlobalProps(value ?: emptyMap())
+            }
+
+            Prop("autoGlobalProps") { view: LynxShipExpoView, value: Boolean? ->
+                view.autoGlobalProps = value ?: true
             }
 
             Prop("reloadOnUpdate") { view: LynxShipExpoView, value: Boolean? ->
@@ -25,6 +33,46 @@ class LynxShipExpoModule : Module() {
             AsyncFunction("reload") { view: LynxShipExpoView ->
                 view.reload()
             }
+
+            AsyncFunction("getContainerId") { view: LynxShipExpoView ->
+                view.getContainerId()
+            }
+
+            AsyncFunction("getLoadState") { view: LynxShipExpoView ->
+                view.getLoadState()
+            }
+
+            AsyncFunction("isLoadSuccess") { view: LynxShipExpoView ->
+                view.isLoadSuccess()
+            }
+
+            AsyncFunction("updateData") { view: LynxShipExpoView, data: String, processorName: String? ->
+                view.updateData(data, processorName)
+            }
+
+            AsyncFunction("updateGlobalProps") { view: LynxShipExpoView, props: Map<String, Any?> ->
+                view.updateGlobalProps(props)
+            }
+
+            AsyncFunction("updateGlobalPropsByIncrement") { view: LynxShipExpoView, props: Map<String, Any?> ->
+                view.updateGlobalPropsByIncrement(props)
+            }
+
+            AsyncFunction("sendGlobalEvent") { view: LynxShipExpoView, eventName: String, params: List<Any?> ->
+                view.sendGlobalEvent(eventName, params)
+            }
+
+            AsyncFunction("show") { view: LynxShipExpoView -> view.show() }
+
+            AsyncFunction("hide") { view: LynxShipExpoView -> view.hide() }
+
+            AsyncFunction("updateViewport") { view: LynxShipExpoView, viewport: Map<String, Double> ->
+                view.updateViewport(viewport["width"] ?: 0.0, viewport["height"] ?: 0.0)
+            }
+
+            OnViewDestroys { view: LynxShipExpoView ->
+                view.release()
+            }
         }
     }
 }

package/android/src/main/java/com/lynxship/expo/LynxShipExpoView.kt

@@ -3,8 +3,16 @@ package com.lynxship.expo
 import android.app.Application
 import android.content.Context
 import android.content.SharedPreferences
+import android.content.res.Configuration
 import android.os.Bundle
+import android.os.Build
+import android.os.PowerManager
 import android.provider.Settings
+import android.view.View
+import android.view.View.MeasureSpec
+import android.view.WindowInsets
+import android.view.accessibility.AccessibilityManager
+import com.lynx.react.bridge.JavaOnlyArray
 import com.facebook.drawee.backends.pipeline.Fresco
 import com.facebook.imagepipeline.core.ImagePipelineConfig
 import com.facebook.imagepipeline.memory.PoolConfig
@@ -13,6 +21,10 @@ import com.lynx.service.http.LynxHttpService
 import com.lynx.service.image.LynxImageService
 import com.lynx.service.log.LynxLogService
 import com.lynx.tasm.LynxEnv
+import com.lynx.tasm.LynxError
+import com.lynx.tasm.LynxLoadMeta
+import com.lynx.tasm.LynxUpdateMeta
+import com.lynx.tasm.TemplateData
 import com.lynx.tasm.LynxView
 import com.lynx.tasm.LynxViewClient
 import com.lynx.tasm.LynxViewBuilder
@@ -30,13 +42,19 @@ import java.util.UUID
 class LynxShipExpoView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
     private val applicationContext = context.applicationContext
     private val onReady by EventDispatcher()
+    private val onLoadStart by EventDispatcher()
+    private val onResourceFetchStart by EventDispatcher()
+    private val onLoadSuccess by EventDispatcher()
     private val onError by EventDispatcher()
     private val onUpdate by EventDispatcher()
+    private val onShow by EventDispatcher()
+    private val onHide by EventDispatcher()
     private val preferences: SharedPreferences = applicationContext.getSharedPreferences("lynxship-expo", Context.MODE_PRIVATE)
     private val metadata: Bundle = applicationContext.applicationInfo.metaData ?: Bundle()
     private val otaClient = createOtaClient(applicationContext)
     private val templateProvider = object : AbsTemplateProvider() {
         override fun loadTemplate(uri: String, callback: Callback) {
+            post { onResourceFetchStart(mapOf("bundle" to uri)) }
             Thread {
                 try {
                     val bytes = otaClient?.openActiveAsset(uri) ?: readEmbeddedAsset(uri)
@@ -49,21 +67,48 @@ class LynxShipExpoView(context: Context, appContext: AppContext) : ExpoView(cont
         }
     }
     private val lynxView: LynxView
-    var bundleName: String = metadata.getString("com.lynxship.expo.embeddedBundle", "main.lynx.bundle")
-    var initialData: String = ""
+    private var bundleNameValue: String = metadata.getString("com.lynxship.expo.embeddedBundle", "main.lynx.bundle")
+    private var initialDataValue: String = ""
+    private var globalProps: Map<String, Any?> = emptyMap()
     var reloadOnUpdate: Boolean = true
+    var autoGlobalProps: Boolean = true
+        set(value) {
+            field = value
+            if (hasRendered) pushGlobalProps()
+        }
+    private var hasRendered = false
+    private var loadState = "idle"
+    private var started = false
+    private val containerId = UUID.randomUUID().toString()
+    private val containerInitTime = System.currentTimeMillis().toString()
+    private var appInBackground = false
 
     init {
         initializeLynx(context)
-        lynxView = LynxViewBuilder().setTemplateProvider(templateProvider).build(applicationContext)
+        // The Lynx view must be created with the host/view context. Keep the
+        // application context only for process-wide services and storage.
+        lynxView = LynxViewBuilder().setTemplateProvider(templateProvider).build(context)
         lynxView.addLynxViewClient(object : LynxViewClient() {
+            override fun onPageStart(url: String?) {
+                loadState = "loading"
+                onLoadStart(mapOf("bundle" to (url ?: bundleNameValue)))
+            }
+
             override fun onFirstScreen() {
+                loadState = "loaded"
                 try {
                     otaClient?.markLaunchSuccess()
                 } catch (error: IOException) {
                     onError(mapOf("message" to (error.message ?: "Could not record Lynx launch"), "recoverable" to true))
                 }
-                onReady(mapOf("bundle" to bundleName, "sequence" to (otaClient?.activeSequence() ?: 0)))
+                val event = mapOf("bundle" to bundleNameValue, "sequence" to (otaClient?.activeSequence() ?: 0))
+                onLoadSuccess(event)
+                onReady(event)
+            }
+
+            override fun onReceivedError(error: LynxError) {
+                loadState = "failed"
+                onError(mapOf("message" to error.toString(), "recoverable" to false))
             }
         })
         addView(lynxView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
@@ -71,27 +116,238 @@ class LynxShipExpoView(context: Context, appContext: AppContext) : ExpoView(cont
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
+        lynxView.onEnterForeground()
+        onShow(emptyMap<String, Any>())
+        if (started) return
+        started = true
         try {
             otaClient?.beginLaunch()
             installUpdateInBackground()
-            render()
+            if (!hasRendered) render()
         } catch (error: Exception) {
             onError(mapOf("message" to (error.message ?: "Lynx startup failed")))
         }
     }
 
+    override fun onDetachedFromWindow() {
+        lynxView.onEnterBackground()
+        onHide(emptyMap<String, Any>())
+        super.onDetachedFromWindow()
+    }
+
     fun reload() {
         render()
     }
 
+    fun getContainerId(): String = containerId
+
+    fun getLoadState(): String = loadState
+
+    fun isLoadSuccess(): Boolean = loadState == "loaded"
+
+    fun updateData(data: String, processorName: String? = null) {
+        require(data.length <= 8 * 1024 * 1024) { "Lynx update data is larger than 8 MiB" }
+        check(hasRendered) { "Lynx view has not loaded a bundle" }
+        if (processorName != null) {
+            require(processorName.isNotBlank() && processorName.length <= 256 && processorName.none { it.isISOControl() }) {
+                "Lynx data processor name is invalid"
+            }
+        }
+        val templateData = TemplateData.fromString(data)
+        processorName?.let(templateData::markState)
+        val builder = LynxUpdateMeta.Builder()
+        builder.setUpdatedData(templateData)
+        lynxView.updateMetaData(builder.build())
+        initialDataValue = data
+        onUpdate(mapOf("bundle" to bundleNameValue, "reason" to "data"))
+    }
+
+    fun setBundleName(value: String) {
+        if (value == bundleNameValue) return
+        bundleNameValue = value
+        if (started) render()
+    }
+
+    fun setInitialData(value: String) {
+        if (value == initialDataValue) return
+        initialDataValue = value
+        if (started) render()
+    }
+
+    fun updateGlobalProps(props: Map<String, Any?>) {
+        globalProps = props.toMap()
+        pushGlobalProps()
+    }
+
+    fun updateGlobalPropsByIncrement(props: Map<String, Any?>) {
+        if (props.isEmpty()) return
+        globalProps = buildMap {
+            putAll(globalProps)
+            putAll(props)
+        }
+        lynxView.updateGlobalProps(TemplateData.fromMap(props))
+    }
+
+    fun sendGlobalEvent(eventName: String, params: List<Any?>) {
+        require(eventName.isNotBlank()) { "Lynx global event name cannot be blank" }
+        require(eventName.length <= 256) { "Lynx global event name is too long" }
+        require(params.size <= 256) { "Lynx global event payload is too large" }
+        lynxView.sendGlobalEvent(
+            eventName,
+            JavaOnlyArray.from(params),
+        )
+    }
+
+    fun show() {
+        visibility = View.VISIBLE
+    }
+
+    fun hide() {
+        visibility = View.INVISIBLE
+    }
+
+    fun updateViewport(width: Double, height: Double) {
+        require(width.isFinite() && height.isFinite() && width >= 0 && height >= 0) {
+            "Lynx viewport dimensions must be finite and non-negative"
+        }
+        lynxView.updateViewport(
+            MeasureSpec.makeMeasureSpec(width.toInt(), MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height.toInt(), MeasureSpec.EXACTLY),
+        )
+    }
+
     private fun render() {
         try {
-            lynxView.renderTemplateUrl(bundleName, initialData)
+            loadState = "loading"
+            val builder = LynxLoadMeta.Builder()
+            builder.setUrl(bundleNameValue)
+            if (initialDataValue.isNotEmpty()) {
+                builder.setInitialData(TemplateData.fromString(initialDataValue))
+            }
+            if (autoGlobalProps || globalProps.isNotEmpty()) {
+                builder.setGlobalProps(TemplateData.fromMap(effectiveGlobalProps()))
+            }
+            lynxView.loadTemplate(builder.build())
+            hasRendered = true
         } catch (error: Exception) {
+            loadState = "failed"
             onError(mapOf("message" to (error.message ?: "Lynx render failed")))
         }
     }
 
+    override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
+        super.onSizeChanged(width, height, oldWidth, oldHeight)
+        if (width > 0 && height > 0) {
+            lynxView.updateViewport(
+                MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+                MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
+            )
+            if (hasRendered && autoGlobalProps) pushGlobalProps()
+        }
+    }
+
+    override fun onWindowVisibilityChanged(visibility: Int) {
+        super.onWindowVisibilityChanged(visibility)
+        val nextBackground = visibility != View.VISIBLE
+        if (nextBackground == appInBackground) return
+        appInBackground = nextBackground
+        if (hasRendered && autoGlobalProps) pushGlobalProps()
+    }
+
+    private fun pushGlobalProps() {
+        if (!autoGlobalProps && globalProps.isEmpty()) return
+        lynxView.updateGlobalProps(TemplateData.fromMap(effectiveGlobalProps()))
+    }
+
+    private fun effectiveGlobalProps(): Map<String, Any?> {
+        if (!autoGlobalProps) return globalProps
+        val metrics = resources.displayMetrics
+        val density = metrics.density.takeIf { it > 0f } ?: 1f
+        val screenWidth = metrics.widthPixels.toDouble() / density
+        val screenHeight = metrics.heightPixels.toDouble() / density
+        val contentWidth = width.toDouble() / density
+        val contentHeight = height.toDouble() / density
+        val insets = systemInsets()
+        val orientation = if (resources.configuration.orientation == Configuration.ORIENTATION_LANDSCAPE) {
+            "landscape"
+        } else {
+            "portrait"
+        }
+        val night = resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
+        val theme = if (night == Configuration.UI_MODE_NIGHT_YES) "dark" else "light"
+        val locale = resources.configuration.locales[0]?.toLanguageTag() ?: "en-US"
+        val powerManager = getContext().getSystemService(Context.POWER_SERVICE) as? PowerManager
+        val hasCutout = Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && rootWindowInsets?.displayCutout != null
+        val isTablet = resources.configuration.smallestScreenWidthDp >= 600
+        return buildMap {
+            putAll(globalProps)
+            put("os", "android")
+            put("osVersion", Build.VERSION.RELEASE ?: "unknown")
+            put("deviceModel", Build.MODEL ?: "unknown")
+            put("containerID", containerId)
+            put("containerInitTime", containerInitTime)
+            put("screenWidth", screenWidth)
+            put("screenHeight", screenHeight)
+            put("contentWidth", contentWidth.coerceAtLeast(0.0))
+            put("contentHeight", contentHeight.coerceAtLeast(0.0))
+            put("safeAreaInsets", insets)
+            put("pixelRatio", density.toDouble())
+            put("accessibleMode", accessibilityMode())
+            put("isIPhoneX", 0)
+            put("isIPhoneXMax", 0)
+            put("isPad", if (isTablet) 1 else 0)
+            put("isNotchScreen", hasCutout)
+            put("isLowPowerMode", if (powerManager?.isPowerSaveMode == true) 1 else 0)
+            put("orientation", orientation)
+            put("screenOrientation", orientation)
+            put("theme", theme)
+            put("appLanguage", locale.substringBefore('-'))
+            put("appLocale", locale)
+            put("isAppBackground", appInBackground)
+            put("queryItems", emptyMap<String, String>())
+            put("statusBarHeight", insets["top"] ?: 0.0)
+            put("navigationBarHeight", insets["bottom"] ?: 0.0)
+            put("safeAreaHeight", insets["top"] ?: 0.0)
+        }
+    }
+
+    private fun systemInsets(): Map<String, Double> {
+        val insets = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            rootWindowInsets?.getInsets(WindowInsets.Type.systemBars())
+        } else {
+            null
+        }
+        val density = resources.displayMetrics.density.takeIf { it > 0f } ?: 1f
+        if (insets != null) {
+            return mapOf(
+                "top" to (insets.top / density).toDouble(),
+                "right" to (insets.right / density).toDouble(),
+                "bottom" to (insets.bottom / density).toDouble(),
+                "left" to (insets.left / density).toDouble(),
+            )
+        }
+        val legacy = rootWindowInsets
+        return mapOf(
+            "top" to (((legacy?.systemWindowInsetTop ?: 0) / density).toDouble()),
+            "right" to (((legacy?.systemWindowInsetRight ?: 0) / density).toDouble()),
+            "bottom" to (((legacy?.systemWindowInsetBottom ?: 0) / density).toDouble()),
+            "left" to (((legacy?.systemWindowInsetLeft ?: 0) / density).toDouble()),
+        )
+    }
+
+    private fun accessibilityMode(): Int {
+        val manager = getContext().getSystemService(Context.ACCESSIBILITY_SERVICE) as? AccessibilityManager
+        return if (manager?.isTouchExplorationEnabled == true) 1 else 0
+    }
+
+    fun release() {
+        if (hasRendered) {
+            lynxView.destroy()
+            hasRendered = false
+        }
+        loadState = "released"
+    }
+
     private fun installUpdateInBackground() {
         otaClient?.checkAndInstallAsync(object : LynxShipOtaClient.Listener {
             override fun onSuccess(updateAvailable: Boolean) {

package/app.plugin.cjs

@@ -7,6 +7,7 @@ const {
   withSettingsGradle,
   withXcodeProject,
   IOSConfig,
+  withPlugins,
 } = require("@expo/config-plugins");
 const path = require("node:path");
 const { syncLynxAssets } = require("./asset-sync.cjs");
@@ -78,6 +79,31 @@ function assertOptions(options) {
     typeof options.syncBundle !== "boolean"
   )
     throw new Error("@lynxship/expo syncBundle must be a boolean");
+  if (options.notifications !== undefined) {
+    if (
+      typeof options.notifications !== "object" ||
+      options.notifications === null ||
+      typeof options.notifications.enabled !== "boolean"
+    )
+      throw new Error(
+        "@lynxship/expo notifications must be an object with boolean enabled",
+      );
+    if (
+      options.notifications.enableBackgroundRemoteNotifications !== undefined &&
+      typeof options.notifications.enableBackgroundRemoteNotifications !==
+        "boolean"
+    )
+      throw new Error(
+        "@lynxship/expo enableBackgroundRemoteNotifications must be a boolean",
+      );
+  }
+  if (
+    options.notifications?.communicationNotifications !== undefined &&
+    typeof options.notifications.communicationNotifications !== "boolean"
+  )
+    throw new Error(
+      "@lynxship/expo communicationNotifications must be a boolean",
+    );
   if (
     options.embeddedBundle !== undefined &&
     (typeof options.embeddedBundle !== "string" ||
@@ -157,6 +183,14 @@ function withLynxShipInfoPlist(config, options) {
       publicKeys: options.publicKeys || {},
       maxReleaseBytes: options.maxReleaseBytes || 104857600,
     };
+    if (options.notifications?.communicationNotifications) {
+      const activityTypes = Array.isArray(value.modResults.NSUserActivityTypes)
+        ? value.modResults.NSUserActivityTypes
+        : [];
+      if (!activityTypes.includes("INSendMessageIntent"))
+        activityTypes.push("INSendMessageIntent");
+      value.modResults.NSUserActivityTypes = activityTypes;
+    }
     return value;
   });
 }
@@ -286,6 +320,28 @@ function withLynxShipIosAssets(config, options) {
   });
 }
 
+function withLynxShipNotifications(config, options) {
+  const notifications = options.notifications;
+  if (!notifications?.enabled) return config;
+  try {
+    return withPlugins(config, [
+      [
+        "expo-notifications",
+        {
+          ...(notifications.android || {}),
+          enableBackgroundRemoteNotifications:
+            notifications.enableBackgroundRemoteNotifications || false,
+        },
+      ],
+    ]);
+  } catch (error) {
+    throw new Error(
+      "@lynxship/expo notifications requires expo-notifications. Install it with `npx expo install expo-notifications`.",
+      { cause: error },
+    );
+  }
+}
+
 function withLynxShipExpo(config, props = {}) {
   const options = assertOptions({ ...getOptions(config), ...props });
   let result = withLynxShipAndroidManifest(config, options);
@@ -294,7 +350,8 @@ function withLynxShipExpo(config, props = {}) {
   result = withLynxShipAndroidSdk(result);
   result = withLynxShipAndroidAssets(result, options);
   result = withLynxShipIosAssets(result, options);
-  return withLynxShipPodfile(result, options);
+  result = withLynxShipPodfile(result, options);
+  return withLynxShipNotifications(result, options);
 }
 
 module.exports = withLynxShipExpo;

package/asset-sync.cjs.d.cts

@@ -0,0 +1,43 @@
+declare const assetSync: {
+  createBundlePlan(
+    projectRoot: string,
+    options?: {
+      bundlePath?: string;
+      embeddedBundle?: string;
+    },
+  ): Promise<{
+    sourceBundle: string;
+    sourceDirectory: string;
+    bundlePath: string;
+    embeddedBundle: string;
+    files: Array<{
+      absolute: string;
+      relative: string;
+      destination: string;
+    }>;
+  }>;
+  syncBundleDirectory(options: {
+    projectRoot: string;
+    plan: Awaited<ReturnType<typeof assetSync.createBundlePlan>>;
+    destinationRoot: string;
+    manifestPath: string;
+    platform: "android" | "ios";
+  }): Promise<{
+    platform: "android" | "ios";
+    sourceBundle: string;
+    destinationRoot: string;
+    manifestPath: string;
+    files: Array<{ path: string; size: number; sha256: string }>;
+  }>;
+  syncLynxAssets(
+    projectRoot: string,
+    options?: {
+      platform?: "android" | "ios";
+      bundlePath?: string;
+      embeddedBundle?: string;
+      iosSourceRoot?: string;
+    },
+  ): Promise<unknown>;
+};
+
+export = assetSync;