pulse-updates 1.2.5 → 1.3.0

package/README.md

@@ -1,9 +1,9 @@
 <p align="center"><img src="logo.png" width="88" alt="Pulse Updates" /></p>
-<h1 align="center">Pulse Updates — React Native SDK</h1>
+<h1 align="center">Pulse — React Native app-experience SDK</h1>
 <p align="center">
-  <b>Lightweight over-the-air (OTA) updates for React Native.</b><br/>
-  Ship JavaScript &amp; assets instantly — a simpler, self-hostable alternative to expo-updates,
-  with full New Architecture (Fabric/Bridgeless) support and Ed25519 signature verification.
+  <b>Updates, config, experiments, events, decisions and first-party links in one SDK.</b><br/>
+  Build measurable app experiences and ship JavaScript &amp; assets safely, with a self-hostable
+  control plane, New Architecture support and fail-closed Ed25519 verification.
 </p>
 
 ---
@@ -77,12 +77,63 @@ Unknown events remain visible and must be approved in the PULSE dashboard.
 
 OTA updates are the other half of the package and set up separately — see below.
 
+## Pulse Links
+
+Pulse owns the reusable installed-app transport; Encore remains the phase-one Smart Link resolver
+and campaign ledger. The client persists only the opaque handoff state, retries transient failures,
+applies each resolved action once and accepts only app-owned deep-link prefixes:
+
+```ts
+import {
+  createPulseLinkClient,
+  DeferredLinkPasteButton,
+  recoverAndroidInstallReferrer,
+} from 'pulse-updates';
+
+const links = createPulseLinkClient({
+  appSlug: 'my-app',
+  resolverBaseUrl: 'https://encore.example.com/t/d',
+  storage: mmkv,
+  allowedDeepLinkPrefixes: ['myapp://', 'https://myapp.example/app/'],
+  isAccountReady: () => auth.isSignedIn && !auth.isGuest,
+  subscribeAccountState: auth.subscribe,
+  accountBridge: {
+    claim: (token) => billing.claimDeferredLink(token),
+    pending: () => billing.getPendingDeferredLink(),
+  },
+  onDeepLink: (url) => navigation.open(url),
+  onAction: (link) => applyClosedAppAction(link.action),
+  // Safe marketing dimensions only. The opaque token/link id is deliberately absent.
+  onOutcome: ({ name, matchBasis, confidence, campaignId }) =>
+    pulse.track(name, { matchBasis, confidence, campaignId }),
+});
+
+// Universal/App Link while the app is installed.
+links.captureUrl(incomingUrl);
+
+// Android: reads the optional PulseAttribution bridge. The host keeps
+// playStoreImplementation 'com.android.installreferrer:installreferrer:2.2'; non-Play builds
+// contain no Google dependency and return FEATURE_NOT_SUPPORTED.
+void recoverAndroidInstallReferrer(links);
+```
+
+On a recent iOS first open, the host may call `links.matchFirstOpen` with its native install time,
+bundle id and locale. The request intentionally contains no device id, account, clipboard value,
+hardware attributes or client-observed IP. Ambiguous matches produce no action. Sensitive actions
+are rejected for every probabilistic result even if a malformed server response claims otherwise.
+
+For the explicit iOS recovery fallback, render `DeferredLinkPasteButton` and pass its validated
+token to `links.capture(token, 'ios_user_paste')`. It uses the system `UIPasteControl` on iOS 16+
+and never reads the clipboard passively. Adding Pulse Links native capabilities requires a new
+App Store/Play binary; Pulse's OTA capability preflight must not be bypassed.
+
 ## Features
 
 - One-call setup for config, experiments and events (`initPulse`)
 - Remote config with typed getters and a default that is never `false` by accident
 - A/B experiments assigned server-side, with the arm carried in the payload
 - Your own events (`track`) — no warehouse required
+- First-party deferred-link transport and privacy-safe install recovery (`createPulseLinkClient`)
 - Full support for React Native New Architecture (Bridgeless mode)
 - Automatic asset resolution with embedded fallback
 - Hermes bytecode compilation for faster startup

package/android/build.gradle

@@ -22,6 +22,7 @@ android {
     defaultConfig {
         minSdkVersion safeExtGet('minSdkVersion', 23)
         targetSdkVersion safeExtGet('targetSdkVersion', 34)
+        consumerProguardFiles 'consumer-rules.pro'
     }
 
     sourceSets {

package/android/consumer-rules.pro

@@ -0,0 +1,21 @@
+# PulseAttribution loads this optional Play-flavor API by exact class and method name. Keep only
+# that reflected public surface; non-Play variants still package no Install Referrer bytecode.
+-keep,allowoptimization class com.android.installreferrer.api.InstallReferrerClient {
+    public static com.android.installreferrer.api.InstallReferrerClient$Builder newBuilder(android.content.Context);
+    public void startConnection(com.android.installreferrer.api.InstallReferrerStateListener);
+    public com.android.installreferrer.api.ReferrerDetails getInstallReferrer();
+    public void endConnection();
+}
+
+-keep,allowoptimization class com.android.installreferrer.api.InstallReferrerClient$Builder {
+    public com.android.installreferrer.api.InstallReferrerClient build();
+}
+
+-keep,allowoptimization interface com.android.installreferrer.api.InstallReferrerStateListener {
+    public void onInstallReferrerSetupFinished(int);
+    public void onInstallReferrerServiceDisconnected();
+}
+
+-keep,allowoptimization class com.android.installreferrer.api.ReferrerDetails {
+    public java.lang.String getInstallReferrer();
+}

package/android/src/main/java/app/pulse/updates/PulseUpdatesPackage.kt

@@ -1,5 +1,6 @@
 package app.pulse.updates
 
+import app.pulse.updates.attribution.PulseAttributionModule
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
@@ -7,7 +8,10 @@ import com.facebook.react.uimanager.ViewManager
 
 class PulseUpdatesPackage : ReactPackage {
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(PulseUpdatesModule(reactContext))
+        return listOf(
+            PulseUpdatesModule(reactContext),
+            PulseAttributionModule(reactContext),
+        )
     }
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

package/android/src/main/java/app/pulse/updates/attribution/DeferredHandoffReferrerParser.kt

@@ -0,0 +1,47 @@
+package app.pulse.updates.attribution
+
+import java.net.URLDecoder
+import java.nio.charset.StandardCharsets
+
+/**
+ * Extracts the one attribution value the SDK is allowed to expose.
+ *
+ * Install Referrer returns an application/x-www-form-urlencoded query string. Keep this parser
+ * deliberately narrow: other campaign parameters, the original referrer, and its metadata never
+ * cross the native bridge.
+ */
+internal object DeferredHandoffReferrerParser {
+    const val MAX_REFERRER_LENGTH = 4_096
+
+    private const val HANDOFF_PARAMETER = "encore_handoff"
+    private val tokenPattern = Regex("^[A-Za-z0-9_-]{16,512}$")
+
+    fun extract(referrer: String): String? {
+        if (referrer.isEmpty() || referrer.length > MAX_REFERRER_LENGTH) return null
+
+        var candidate: String? = null
+        var matches = 0
+
+        for (part in referrer.split('&')) {
+            val separator = part.indexOf('=')
+            val encodedKey = if (separator >= 0) part.substring(0, separator) else part
+            val key = decode(encodedKey) ?: continue
+            if (key != HANDOFF_PARAMETER) continue
+
+            matches += 1
+            // Ambiguous referrers are rejected even if just one of the duplicate values is valid.
+            if (matches > 1) return null
+
+            val encodedValue = if (separator >= 0) part.substring(separator + 1) else ""
+            candidate = decode(encodedValue) ?: return null
+        }
+
+        return candidate?.takeIf(tokenPattern::matches)
+    }
+
+    private fun decode(value: String): String? = try {
+        URLDecoder.decode(value, StandardCharsets.UTF_8.name())
+    } catch (_: IllegalArgumentException) {
+        null
+    }
+}

package/android/src/main/java/app/pulse/updates/attribution/InstallReferrerReflection.kt

@@ -0,0 +1,155 @@
+package app.pulse.updates.attribution
+
+import android.content.Context
+import java.lang.reflect.InvocationHandler
+import java.lang.reflect.Method
+import java.lang.reflect.Proxy
+import java.util.concurrent.atomic.AtomicBoolean
+
+/** Reflection-only access to Play Install Referrer. Non-Play variants do not package these types. */
+internal class InstallReferrerReflection private constructor(
+    private val listenerClass: Class<*>,
+    private val newBuilder: Method,
+    private val build: Method,
+    private val startConnection: Method,
+    private val getInstallReferrer: Method,
+    private val getInstallReferrerValue: Method,
+    private val endConnection: Method,
+) {
+    sealed class LoadResult {
+        class Available(val api: InstallReferrerReflection) : LoadResult()
+        object Missing : LoadResult()
+        object Broken : LoadResult()
+    }
+
+    interface Listener {
+        fun onSetupFinished(responseCode: Int)
+        fun onServiceDisconnected()
+    }
+
+    fun createConnection(context: Context): Connection {
+        val builder = newBuilder.invoke(null, context.applicationContext)
+            ?: throw ReflectiveOperationException("Install Referrer builder was null")
+        val client = build.invoke(builder)
+            ?: throw ReflectiveOperationException("Install Referrer client was null")
+        return Connection(
+            client = client,
+            listenerClass = listenerClass,
+            startConnection = startConnection,
+            getInstallReferrer = getInstallReferrer,
+            getInstallReferrerValue = getInstallReferrerValue,
+            endConnection = endConnection,
+        )
+    }
+
+    class Connection internal constructor(
+        private val client: Any,
+        private val listenerClass: Class<*>,
+        private val startConnection: Method,
+        private val getInstallReferrer: Method,
+        private val getInstallReferrerValue: Method,
+        private val endConnection: Method,
+    ) {
+        private val closed = AtomicBoolean(false)
+
+        @Volatile
+        private var listenerProxy: Any? = null
+
+        fun start(listener: Listener) {
+            check(!closed.get()) { "Install Referrer connection is closed" }
+            val handler = InvocationHandler { proxy, method, args ->
+                when (method.name) {
+                    "onInstallReferrerSetupFinished" -> {
+                        val code = (args?.firstOrNull() as? Number)?.toInt()
+                        if (code == null) listener.onSetupFinished(DEVELOPER_ERROR)
+                        else listener.onSetupFinished(code)
+                        null
+                    }
+                    "onInstallReferrerServiceDisconnected" -> {
+                        listener.onServiceDisconnected()
+                        null
+                    }
+                    "equals" -> proxy === args?.firstOrNull()
+                    "hashCode" -> System.identityHashCode(proxy)
+                    "toString" -> "PulseInstallReferrerListener"
+                    else -> null
+                }
+            }
+            val proxy = Proxy.newProxyInstance(
+                listenerClass.classLoader ?: client.javaClass.classLoader,
+                arrayOf(listenerClass),
+                handler,
+            )
+            listenerProxy = proxy
+            startConnection.invoke(client, proxy)
+        }
+
+        fun readReferrer(): String {
+            check(!closed.get()) { "Install Referrer connection is closed" }
+            val details = getInstallReferrer.invoke(client)
+                ?: throw ReflectiveOperationException("Install Referrer details were null")
+            return getInstallReferrerValue.invoke(details) as? String
+                ?: throw ReflectiveOperationException("Install Referrer value was null")
+        }
+
+        /** Safe from timeout, callback, retry, and module invalidation races. */
+        fun close() {
+            if (!closed.compareAndSet(false, true)) return
+            try {
+                endConnection.invoke(client)
+            } catch (_: Throwable) {
+                // Cleanup is best-effort and must never replace the already selected result.
+            } finally {
+                listenerProxy = null
+            }
+        }
+    }
+
+    companion object {
+        const val OK = 0
+        const val SERVICE_UNAVAILABLE = 1
+        const val FEATURE_NOT_SUPPORTED = 2
+        const val DEVELOPER_ERROR = 3
+        const val SERVICE_DISCONNECTED = -1
+
+        private const val CLIENT_CLASS =
+            "com.android.installreferrer.api.InstallReferrerClient"
+        private const val BUILDER_CLASS =
+            "com.android.installreferrer.api.InstallReferrerClient\$Builder"
+        private const val LISTENER_CLASS =
+            "com.android.installreferrer.api.InstallReferrerStateListener"
+        private const val DETAILS_CLASS =
+            "com.android.installreferrer.api.ReferrerDetails"
+
+        fun load(context: Context): LoadResult {
+            val loader = context.classLoader ?: InstallReferrerReflection::class.java.classLoader
+            return try {
+                val client = Class.forName(CLIENT_CLASS, false, loader)
+                val builder = Class.forName(BUILDER_CLASS, false, loader)
+                val listener = Class.forName(LISTENER_CLASS, false, loader)
+                val details = Class.forName(DETAILS_CLASS, false, loader)
+                LoadResult.Available(
+                    InstallReferrerReflection(
+                        listenerClass = listener,
+                        newBuilder = client.getMethod("newBuilder", Context::class.java),
+                        build = builder.getMethod("build"),
+                        startConnection = client.getMethod("startConnection", listener),
+                        getInstallReferrer = client.getMethod("getInstallReferrer"),
+                        getInstallReferrerValue = details.getMethod("getInstallReferrer"),
+                        endConnection = client.getMethod("endConnection"),
+                    ),
+                )
+            } catch (_: ClassNotFoundException) {
+                LoadResult.Missing
+            } catch (_: NoClassDefFoundError) {
+                LoadResult.Missing
+            } catch (_: ReflectiveOperationException) {
+                LoadResult.Broken
+            } catch (_: SecurityException) {
+                LoadResult.Broken
+            } catch (_: LinkageError) {
+                LoadResult.Broken
+            }
+        }
+    }
+}

package/android/src/main/java/app/pulse/updates/attribution/PulseAttributionModule.kt

@@ -0,0 +1,229 @@
+package app.pulse.updates.attribution
+
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import java.util.Collections
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * A separate native capability so an OTA that expects attribution fails closed on older binaries.
+ */
+class PulseAttributionModule(
+    private val reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val activeRequests = Collections.synchronizedSet(mutableSetOf<DeferredHandoffRequest>())
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun getDeferredHandoff(promise: Promise) {
+        lateinit var request: DeferredHandoffRequest
+        request = DeferredHandoffRequest(
+            context = reactContext.applicationContext,
+            promise = promise,
+            handler = mainHandler,
+            onSettled = { activeRequests.remove(request) },
+        )
+        activeRequests.add(request)
+        request.start()
+    }
+
+    override fun invalidate() {
+        val pending = synchronized(activeRequests) { activeRequests.toList() }
+        pending.forEach(DeferredHandoffRequest::cancel)
+        activeRequests.clear()
+        super.invalidate()
+    }
+
+    companion object {
+        const val NAME = "PulseAttribution"
+    }
+}
+
+private enum class DeferredHandoffStatus(val retryable: Boolean) {
+    OK(false),
+    NO_TOKEN(false),
+    FEATURE_NOT_SUPPORTED(false),
+    SERVICE_UNAVAILABLE(true),
+    DEVELOPER_ERROR(false),
+    SERVICE_DISCONNECTED(true),
+}
+
+private class DeferredHandoffRequest(
+    private val context: android.content.Context,
+    private val promise: Promise,
+    private val handler: Handler,
+    private val onSettled: () -> Unit,
+) {
+    private val settled = AtomicBoolean(false)
+    private var attempts = 0
+    private var lastTransientStatus = DeferredHandoffStatus.SERVICE_UNAVAILABLE
+
+    @Volatile
+    private var activeConnection: InstallReferrerReflection.Connection? = null
+
+    private val timeout = Runnable {
+        settle(lastTransientStatus, null)
+    }
+
+    fun start() {
+        handler.post {
+            if (settled.get()) return@post
+            when (val loaded = InstallReferrerReflection.load(context)) {
+                is InstallReferrerReflection.LoadResult.Available -> {
+                    handler.postDelayed(timeout, TIMEOUT_MS)
+                    beginAttempt(loaded.api)
+                }
+                InstallReferrerReflection.LoadResult.Missing -> {
+                    settle(DeferredHandoffStatus.FEATURE_NOT_SUPPORTED, null)
+                }
+                InstallReferrerReflection.LoadResult.Broken -> {
+                    settle(DeferredHandoffStatus.DEVELOPER_ERROR, null)
+                }
+            }
+        }
+    }
+
+    fun cancel() {
+        settle(DeferredHandoffStatus.SERVICE_UNAVAILABLE, null)
+    }
+
+    private fun beginAttempt(api: InstallReferrerReflection) {
+        if (settled.get()) return
+        attempts += 1
+
+        val callbackConsumed = AtomicBoolean(false)
+        val connection = try {
+            api.createConnection(context)
+        } catch (_: Throwable) {
+            settle(DeferredHandoffStatus.DEVELOPER_ERROR, null)
+            return
+        }
+        if (settled.get()) {
+            connection.close()
+            return
+        }
+        activeConnection = connection
+
+        val listener = object : InstallReferrerReflection.Listener {
+            override fun onSetupFinished(responseCode: Int) {
+                if (!callbackConsumed.compareAndSet(false, true)) return
+                handler.post {
+                    if (settled.get()) {
+                        connection.close()
+                        return@post
+                    }
+                    when (responseCode) {
+                        InstallReferrerReflection.OK -> readAndSettle(connection, api)
+                        InstallReferrerReflection.SERVICE_UNAVAILABLE -> retryTransient(
+                            connection,
+                            api,
+                            DeferredHandoffStatus.SERVICE_UNAVAILABLE,
+                        )
+                        InstallReferrerReflection.SERVICE_DISCONNECTED -> retryTransient(
+                            connection,
+                            api,
+                            DeferredHandoffStatus.SERVICE_DISCONNECTED,
+                        )
+                        InstallReferrerReflection.FEATURE_NOT_SUPPORTED -> {
+                            connection.close()
+                            settle(DeferredHandoffStatus.FEATURE_NOT_SUPPORTED, null)
+                        }
+                        InstallReferrerReflection.DEVELOPER_ERROR -> {
+                            connection.close()
+                            settle(DeferredHandoffStatus.DEVELOPER_ERROR, null)
+                        }
+                        // 2.2 also defines PERMISSION_ERROR. The public bridge intentionally has
+                        // no Play-specific status for it, so it is a terminal developer error.
+                        else -> {
+                            connection.close()
+                            settle(DeferredHandoffStatus.DEVELOPER_ERROR, null)
+                        }
+                    }
+                }
+            }
+
+            override fun onServiceDisconnected() {
+                if (!callbackConsumed.compareAndSet(false, true)) return
+                handler.post {
+                    if (settled.get()) {
+                        connection.close()
+                        return@post
+                    }
+                    retryTransient(
+                        connection,
+                        api,
+                        DeferredHandoffStatus.SERVICE_DISCONNECTED,
+                    )
+                }
+            }
+        }
+
+        try {
+            connection.start(listener)
+        } catch (_: Throwable) {
+            if (callbackConsumed.compareAndSet(false, true)) {
+                connection.close()
+                settle(DeferredHandoffStatus.DEVELOPER_ERROR, null)
+            }
+        }
+    }
+
+    private fun readAndSettle(
+        connection: InstallReferrerReflection.Connection,
+        api: InstallReferrerReflection,
+    ) {
+        val referrer = try {
+            connection.readReferrer()
+        } catch (_: Throwable) {
+            retryTransient(connection, api, DeferredHandoffStatus.SERVICE_DISCONNECTED)
+            return
+        }
+        connection.close()
+
+        val token = DeferredHandoffReferrerParser.extract(referrer)
+        if (token == null) settle(DeferredHandoffStatus.NO_TOKEN, null)
+        else settle(DeferredHandoffStatus.OK, token)
+    }
+
+    private fun retryTransient(
+        connection: InstallReferrerReflection.Connection,
+        api: InstallReferrerReflection,
+        status: DeferredHandoffStatus,
+    ) {
+        connection.close()
+        lastTransientStatus = status
+        if (attempts < MAX_ATTEMPTS) beginAttempt(api)
+        else settle(status, null)
+    }
+
+    private fun settle(status: DeferredHandoffStatus, token: String?) {
+        if (!settled.compareAndSet(false, true)) return
+        handler.removeCallbacks(timeout)
+        activeConnection?.close()
+        activeConnection = null
+
+        val result = Arguments.createMap().apply {
+            putString("status", status.name)
+            putBoolean("retryable", status.retryable)
+            putInt("attempts", attempts)
+            if (token == null) putNull("token") else putString("token", token)
+        }
+        try {
+            promise.resolve(result)
+        } finally {
+            onSettled()
+        }
+    }
+
+    companion object {
+        private const val TIMEOUT_MS = 5_000L
+        private const val MAX_ATTEMPTS = 3
+    }
+}

package/ios/PulseAttribution/PulseAttribution.m

@@ -0,0 +1,29 @@
+#import <React/RCTBridgeModule.h>
+
+/// Cross-platform native capability marker. Android supplies Play Install Referrer through an
+/// optional reflected dependency; iOS deterministic recovery uses Universal Links/UIPasteControl.
+@interface PulseAttribution : NSObject <RCTBridgeModule>
+@end
+
+@implementation PulseAttribution
+
+RCT_EXPORT_MODULE(PulseAttribution)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+RCT_REMAP_METHOD(getDeferredHandoff,
+                 getDeferredHandoffWithResolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+{
+  resolve(@{
+    @"status": @"FEATURE_NOT_SUPPORTED",
+    @"retryable": @NO,
+    @"attempts": @0,
+    @"token": [NSNull null],
+  });
+}
+
+@end

package/ios/PulseAttribution/PulseDeferredLinkPasteButtonComponentView.h

@@ -0,0 +1,13 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface PulseDeferredLinkPasteButtonComponentView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/PulseAttribution/PulseDeferredLinkPasteButtonComponentView.mm

@@ -0,0 +1,81 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "PulseDeferredLinkPasteButtonComponentView.h"
+#import "PulseDeferredLinkPasteView.h"
+
+#import <react/renderer/components/PulseAttributionSpec/ComponentDescriptors.h>
+#import <react/renderer/components/PulseAttributionSpec/EventEmitters.h>
+#import <react/renderer/components/PulseAttributionSpec/Props.h>
+#import <react/renderer/components/PulseAttributionSpec/RCTComponentViewHelpers.h>
+
+#import <React/RCTConversions.h>
+
+using namespace facebook::react;
+
+@interface PulseDeferredLinkPasteButtonComponentView ()
+    <RCTPulseDeferredLinkPasteButtonViewProtocol>
+- (void)emitHandoff:(NSDictionary<NSString *, NSString *> *)body;
+@end
+
+@implementation PulseDeferredLinkPasteButtonComponentView {
+  PulseDeferredLinkPasteView *_pasteView;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<PulseDeferredLinkPasteButtonComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if ((self = [super initWithFrame:frame])) {
+    static const auto defaultProps = std::make_shared<const PulseDeferredLinkPasteButtonProps>();
+    _props = defaultProps;
+    _pasteView = [[PulseDeferredLinkPasteView alloc] initWithFrame:self.bounds];
+    _pasteView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    __weak __typeof(self) weakSelf = self;
+    _pasteView.onHandoff = ^(NSDictionary<NSString *, NSString *> *body) {
+      [weakSelf emitHandoff:body];
+    };
+    self.contentView = _pasteView;
+  }
+  return self;
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldViewProps =
+      *std::static_pointer_cast<const PulseDeferredLinkPasteButtonProps>(_props);
+  const auto &newViewProps =
+      *std::static_pointer_cast<const PulseDeferredLinkPasteButtonProps>(props);
+  if (oldViewProps.label != newViewProps.label) {
+    _pasteView.label = RCTNSStringFromStringNilIfEmpty(newViewProps.label);
+  }
+  if (oldViewProps.foregroundColor != newViewProps.foregroundColor) {
+    _pasteView.foregroundColor = RCTUIColorFromSharedColor(newViewProps.foregroundColor);
+  }
+  if (oldViewProps.handoffPrefix != newViewProps.handoffPrefix) {
+    _pasteView.handoffPrefix = RCTNSStringFromStringNilIfEmpty(newViewProps.handoffPrefix);
+  }
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)emitHandoff:(NSDictionary<NSString *, NSString *> *)body
+{
+  if (!_eventEmitter) return;
+  NSString *token = body[@"token"];
+  if (![token isKindOfClass:NSString.class]) return;
+  PulseDeferredLinkPasteButtonEventEmitter::OnHandoff event = {};
+  event.token = std::string(token.UTF8String);
+  std::static_pointer_cast<const PulseDeferredLinkPasteButtonEventEmitter>(_eventEmitter)
+      ->onHandoff(event);
+}
+
+@end
+
+Class<RCTComponentViewProtocol> PulseDeferredLinkPasteButtonCls(void)
+{
+  return PulseDeferredLinkPasteButtonComponentView.class;
+}
+
+#endif