@advenue/react-native 1.0.1 → 1.1.1

package/android/src/main/kotlin/io/advenue/core/SessionTracker.kt

@@ -5,6 +5,12 @@ internal const val SESSION_STATE_KEY: String = "advenue.session"
 /** 30 minutes. */
 internal const val DEFAULT_SESSION_WINDOW_MS: Long = 1_800_000L
 
+/**
+ * The heartbeat persists at most this often: it runs on every recorded event,
+ * and a chatty app must not turn that into a storage write per event.
+ */
+internal const val SESSION_HEARTBEAT_MIN_INTERVAL_MS: Long = 1_000L
+
 /** A session lifecycle event, wrapped by the engine as a `type: "session"` event. */
 internal data class SessionEvent(val name: String, val properties: Map<String, Any?>)
 
@@ -16,6 +22,12 @@ private data class SessionState(
   val activeStart: Long?,
   val firstForegroundAt: Long,
   val timeSpentMs: Long,
+  /**
+   * The last moment the open sub-session was known to be alive (F-SDK-7).
+   * Absent in state written before it existed, which reads as "alive at
+   * activeStart".
+   */
+  val lastActiveAt: Long? = null,
 ) {
   /**
    * The persisted blob. Field names are frozen: a rename would make RN-written
@@ -30,6 +42,7 @@ private data class SessionState(
       "activeStart" to activeStart,
       "firstForegroundAt" to firstForegroundAt,
       "timeSpentMs" to timeSpentMs,
+      "lastActiveAt" to lastActiveAt,
     )
 }
 
@@ -46,21 +59,88 @@ internal class SessionTracker(
 ) {
   private var lastState: SessionState? = null
 
+  /**
+   * True once THIS process opened the current sub-session (X-SDK-1). Never
+   * persisted: a relaunched process starts false, so its tracks and flushes
+   * before [handleForeground] cannot keep the dead process's sub-session alive
+   * and move its kill time to the relaunch.
+   */
+  private var ownsOpenSubSession = false
+
   /** Drops the cached state (erasure) so a wiped store cannot be resurrected. */
   public fun reset() {
     lastState = null
+    ownsOpenSubSession = false
   }
 
   /**
-   * Foreground transition, including cold start. Returns:
-   * - empty — a sub-session inside the window;
-   * - `[session_start]` — a new session;
-   * - `[session_end, session_start]` — kill recovery: the prior session was
-   *   still open when the OS killed the app, so its end is synthesised first.
+   * Refreshes the open sub-session's last known activity. Called by the engine
+   * on every recorded event and every flush — the auto-flush timer is the
+   * foreground tick. It is what a relaunch after an OS kill measures the gap
+   * from, the role Adjust's `lastActivity` plays.
+   *
+   * A no-op until this process has run [handleForeground]: only the process
+   * that opened the sub-session may extend it. Otherwise an event or flush in a
+   * relaunched process (a background wake from a broadcast, push or WorkManager
+   * before the activity resumes) would stamp the killed sub-session alive "now"
+   * and count the dead time as active (X-SDK-1).
+   */
+  public fun heartbeat() {
+    if (!ownsOpenSubSession) return
+    val state = load() ?: return
+    val activeStart = state.activeStart ?: return
+    val now = clock.nowMs()
+    if (now - (state.lastActiveAt ?: activeStart) < SESSION_HEARTBEAT_MIN_INTERVAL_MS) return
+    save(state.copy(lastActiveAt = now))
+  }
+
+  /**
+   * Foreground transition, including cold start. Returns the events to emit, in
+   * order:
+   * - a synthetic `session_end` first when a sub-session was still open — the
+   *   OS killed the app before it could background. It is closed at its last
+   *   heartbeat, not at the relaunch: the time the app was dead is not active
+   *   time. A consumer must never see two sessions open, so it comes first.
+   * - then, measured from the background (or that kill time): nothing for a
+   *   sub-session inside the window, or a `session_start` for a new session.
+   *
+   * A kill is not a session boundary by itself (F-SDK-7). Adjust's rule — a new
+   * session only after the session interval of inactivity — applies to a
+   * relaunch exactly as it does to a return from the background.
    */
   public fun handleForeground(): List<SessionEvent> {
-    val state = load()
     val now = clock.nowMs()
+    val state = load()
+    val activeStart = state?.activeStart ?: return resume(state, now)
+
+    val killTime = minOf(now, maxOf(activeStart, state.lastActiveAt ?: activeStart))
+    val activeMs = Math.max(0L, killTime - activeStart)
+    val timeSpentMs = state.timeSpentMs + activeMs
+    val sessionEnd =
+      SessionEvent(
+        "session_end",
+        mapOf(
+          "sessionId" to state.sessionId,
+          "sessionNumber" to state.sessionNumber,
+          "subSession" to state.subSessionCount,
+          "activeMs" to activeMs,
+          "timeSpentMs" to timeSpentMs,
+          "sessionLengthMs" to Math.max(0L, killTime - state.firstForegroundAt),
+          "synthetic" to true,
+        ),
+      )
+    val closed =
+      state.copy(
+        lastBackgroundAt = killTime,
+        activeStart = null,
+        lastActiveAt = null,
+        timeSpentMs = timeSpentMs,
+      )
+    return listOf(sessionEnd) + resume(closed, now)
+  }
+
+  /** The foreground decision once no sub-session is open. */
+  private fun resume(state: SessionState?, now: Long): List<SessionEvent> {
     val gap = if (state?.lastBackgroundAt != null) now - state.lastBackgroundAt else null
 
     if (state == null || gap == null || gap >= windowMs) {
@@ -77,8 +157,8 @@ internal class SessionTracker(
           timeSpentMs = 0L,
         ),
       )
-
-      val sessionStart =
+      ownsOpenSubSession = true
+      return listOf(
         SessionEvent(
           "session_start",
           mapOf(
@@ -89,32 +169,18 @@ internal class SessionTracker(
             // 0 rather than infinity, which would not survive JSON.
             "timeSinceLastSessionMs" to (gap ?: 0L),
           ),
-        )
-
-      if (state?.activeStart != null) {
-        val killTime = state.lastBackgroundAt ?: now
-        val activeMs = Math.max(0L, killTime - state.activeStart)
-        val timeSpentMs = state.timeSpentMs + activeMs
-        val sessionEnd =
-          SessionEvent(
-            "session_end",
-            mapOf(
-              "sessionId" to state.sessionId,
-              "sessionNumber" to state.sessionNumber,
-              "subSession" to state.subSessionCount,
-              "activeMs" to activeMs,
-              "timeSpentMs" to timeSpentMs,
-              "sessionLengthMs" to Math.max(0L, killTime - state.firstForegroundAt),
-              "synthetic" to true,
-            ),
-          )
-        return listOf(sessionEnd, sessionStart)
-      }
-
-      return listOf(sessionStart)
+        ),
+      )
     }
 
-    save(state.copy(subSessionCount = state.subSessionCount + 1L, activeStart = now))
+    save(
+      state.copy(
+        subSessionCount = state.subSessionCount + 1L,
+        activeStart = now,
+        lastActiveAt = null,
+      ),
+    )
+    ownsOpenSubSession = true
     return emptyList()
   }
 
@@ -125,7 +191,15 @@ internal class SessionTracker(
     val now = clock.nowMs()
     val activeMs = Math.max(0L, now - activeStart)
     val timeSpentMs = state.timeSpentMs + activeMs
-    save(state.copy(lastBackgroundAt = now, activeStart = null, timeSpentMs = timeSpentMs))
+    save(
+      state.copy(
+        lastBackgroundAt = now,
+        activeStart = null,
+        lastActiveAt = null,
+        timeSpentMs = timeSpentMs,
+      ),
+    )
+    ownsOpenSubSession = false
     return SessionEvent(
       "session_end",
       mapOf(
@@ -157,6 +231,7 @@ internal class SessionTracker(
     // it, an app updating from an older SDK would fail to load its own session
     // and restart its numbering.
     val timeSpentMs = (map["timeSpentMs"] as? Number)?.toLong() ?: 0L
+    val lastActiveAt = (map["lastActiveAt"] as? Number)?.toLong()
     val firstForegroundAt =
       (map["firstForegroundAt"] as? Number)?.toLong()
         ?: activeStart
@@ -172,6 +247,7 @@ internal class SessionTracker(
         activeStart = activeStart,
         firstForegroundAt = firstForegroundAt,
         timeSpentMs = timeSpentMs,
+        lastActiveAt = lastActiveAt,
       )
     lastState = state
     return state

package/android/src/main/kotlin/io/advenue/platform/ConversionFetcher.kt

@@ -24,23 +24,37 @@ public class HttpConversionFetcher(
   private val timeoutMs: Int = 15_000,
 ) : ConversionFetcher {
 
-  override fun fetch(): ConversionResult {
+  internal val requestMethod: String = "GET"
+
+  /**
+   * Sends `?platform=android`: this fetcher is Android-only by construction,
+   * and a project key spans listings, so the server needs the platform to pick
+   * the one this install was filed under (Y-LINKS-1). Without it the lookup
+   * refused the project key the dashboard mints, and the deferred deep link
+   * never arrived. No `store`: the SDK does not report one on events either, so
+   * both sides fall back to the project's default Android store.
+   */
+  internal fun requestUrl(): URL {
     val escaped = URLEncoder.encode(deviceId, "UTF-8")
-    val connection =
-      URL("$endpoint/sdk/conversion-data?deviceId=$escaped").openConnection()
-        as HttpURLConnection
+    return URL("$endpoint/sdk/conversion-data?deviceId=$escaped&platform=android")
+  }
+
+  internal fun requestHeaders(): Map<String, String> = mapOf("x-api-key" to apiKey)
+
+  override fun fetch(): ConversionResult {
+    val connection = requestUrl().openConnection() as HttpURLConnection
     try {
-      connection.requestMethod = "GET"
+      connection.requestMethod = requestMethod
       connection.connectTimeout = timeoutMs
       connection.readTimeout = timeoutMs
-      connection.setRequestProperty("x-api-key", apiKey)
+      for ((name, value) in requestHeaders()) connection.setRequestProperty(name, value)
 
       val status =
         try {
           connection.responseCode
-        } catch (_: IOException) {
+        } catch (error: IOException) {
           // No status to reason about; 408 marks it retryable, as sdk-core does.
-          throw IngestError(408)
+          throw IngestError(408, networkCause = error.javaClass.simpleName)
         }
       if (status < 200 || status >= 300) throw IngestError(status)
 
@@ -59,8 +73,8 @@ public class HttpConversionFetcher(
       )
     } catch (error: IngestError) {
       throw error
-    } catch (_: IOException) {
-      throw IngestError(408)
+    } catch (error: IOException) {
+      throw IngestError(408, networkCause = error.javaClass.simpleName)
     } finally {
       connection.disconnect()
     }

package/android/src/main/kotlin/io/advenue/platform/ForegroundTracker.kt

@@ -38,9 +38,16 @@ internal enum class ForegroundTransition {
  * `ProcessLifecycleOwner`'s constant. We cannot take the dependency, but we can
  * take its number.
  */
-internal class ForegroundTracker {
+internal class ForegroundTracker(seededInForeground: Boolean = false) {
   private var started = 0
-  private var inForeground = false
+
+  /**
+   * Seeded by initialize to match the session it did or did not open. Seeded
+   * as foregrounded, the launcher activity's first start is not a second
+   * foreground, and the stop of an activity that started before the bridge
+   * was registered still reaches the background.
+   */
+  private var inForeground = seededInForeground
   private var backgroundPending = false
 
   public fun onSignal(signal: LifecycleSignal): ForegroundTransition =

package/android/src/main/kotlin/io/advenue/platform/HttpUrlTransport.kt

@@ -5,6 +5,7 @@ import io.advenue.core.ClientEvent
 import io.advenue.core.EventTransport
 import io.advenue.core.IngestError
 import io.advenue.core.JvmHmacSigner
+import io.advenue.core.iso8601
 import io.advenue.core.Signer
 import io.advenue.core.signRequest
 import io.advenue.core.parseJson
@@ -48,8 +49,17 @@ internal class HttpUrlTransport(
    * wire shape without a network round trip, which is the part that has to be
    * right.
    */
-  internal fun buildBody(events: List<ClientEvent>): String =
-    writeCanonicalJson(mapOf("apiKey" to apiKey, "events" to events.map { it.toMap() }))
+  internal fun buildBody(events: List<ClientEvent>, nowMs: Long = clock.nowMs()): String =
+    writeCanonicalJson(
+      mapOf(
+        "apiKey" to apiKey,
+        "events" to events.map { it.toMap() },
+        // The device clock at THIS attempt (spec 2026-10-01-data-fidelity D3):
+        // the server compares it with its receive time to measure the clock
+        // offset, so it is stamped per send and never persisted with the queue.
+        "sentAt" to iso8601(nowMs),
+      ),
+    )
 
   /** The headers for [body]; empty of signature headers when no secret is set. */
   internal fun buildHeaders(body: String, timestamp: String): Map<String, String> {
@@ -61,8 +71,11 @@ internal class HttpUrlTransport(
   }
 
   override fun send(events: List<ClientEvent>) {
-    val body = buildBody(events)
-    val headers = buildHeaders(body, clock.nowMs().toString())
+    // One reading for both `sentAt` and the signed timestamp: they describe the
+    // same instant, and two reads could straddle a clock change.
+    val nowMs = clock.nowMs()
+    val body = buildBody(events, nowMs)
+    val headers = buildHeaders(body, nowMs.toString())
 
     val connection = URL("$endpoint/v1/events").openConnection() as HttpURLConnection
     try {
@@ -77,9 +90,9 @@ internal class HttpUrlTransport(
       val status =
         try {
           connection.responseCode
-        } catch (_: IOException) {
+        } catch (error: IOException) {
           // No response at all is a transient failure, not a poison payload.
-          throw IngestError(408)
+          throw IngestError(408, networkCause = error.javaClass.simpleName)
         }
       if (status < 200 || status >= 300) throw IngestError(status)
 
@@ -92,8 +105,8 @@ internal class HttpUrlTransport(
       }
     } catch (error: IngestError) {
       throw error
-    } catch (_: IOException) {
-      throw IngestError(408)
+    } catch (error: IOException) {
+      throw IngestError(408, networkCause = error.javaClass.simpleName)
     } finally {
       connection.disconnect()
     }

package/android/src/main/kotlin/io/advenue/platform/InstallEnrichment.kt

@@ -28,6 +28,13 @@ import java.util.concurrent.TimeUnit
  */
 internal const val REFERRER_DEADLINE_MS: Long = 5_000
 
+/**
+ * How long past [REFERRER_DEADLINE_MS] flushes stay held for a pending install:
+ * the enrichment thread still has to submit the install through the pipe after
+ * its deadline.
+ */
+internal const val INSTALL_HOLD_MARGIN_MS: Long = 2_000
+
 /** A shorter budget for the enrichment that is not attribution-critical. */
 internal const val ENRICHMENT_DEADLINE_MS: Long = 3_000
 

package/android/src/main/kotlin/io/advenue/platform/LifecycleBridge.kt

@@ -1,6 +1,7 @@
 package io.advenue.platform
 
 import android.app.Activity
+import android.app.ActivityManager
 import android.app.Application
 import android.os.Bundle
 import android.os.Handler
@@ -19,8 +20,9 @@ internal class LifecycleBridge(
   private val application: Application,
   private val onForeground: () -> Unit,
   private val onBackground: () -> Unit,
+  seededInForeground: Boolean,
 ) : Application.ActivityLifecycleCallbacks {
-  private val tracker = ForegroundTracker()
+  private val tracker = ForegroundTracker(seededInForeground)
   private val handler = Handler(Looper.getMainLooper())
   private val debounce = Runnable { apply(tracker.onSignal(LifecycleSignal.DebounceElapsed)) }
 
@@ -70,3 +72,23 @@ internal class LifecycleBridge(
 
   override fun onActivityDestroyed(activity: Activity): Unit = Unit
 }
+
+/**
+ * Whether this process is running for a user-visible launch, read at
+ * initialize. `Application.onCreate` runs for a tapped icon and equally for a
+ * push, a WorkManager job or a broadcast that wakes the process with no
+ * activity; only the first is a session. During a user launch the system has
+ * already made the process top, so its importance is `IMPORTANCE_FOREGROUND`;
+ * a background wake reports a service or cached importance. The same check
+ * crash reporters use to tell a cold start from a background start. True
+ * wherever it cannot be read, which keeps the pre-existing behaviour: the
+ * launch is a foreground.
+ */
+internal fun readLaunchedInForeground(): Boolean =
+  try {
+    val info = ActivityManager.RunningAppProcessInfo()
+    ActivityManager.getMyMemoryState(info)
+    info.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+  } catch (_: Throwable) {
+    true
+  }

package/dist/index.cjs

@@ -65,10 +65,19 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "@advenue/react-native",
-  version: "1.0.1",
+  version: "1.1.1",
   description: "Advenue MMP React Native SDK \u2014 attribution, install tracking, and deep links (bundled iOS/Android Expo native modules)",
   type: "module",
   license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/broverse/advenue.git",
+    directory: "packages/sdk-react-native"
+  },
+  homepage: "https://advenue.io",
+  bugs: {
+    url: "https://github.com/broverse/advenue/issues"
+  },
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
   exports: {
@@ -225,6 +234,7 @@ var started = false;
 var deepLinkSub = null;
 var errorSub = null;
 var onErrorHook;
+var debugLogging = false;
 var consentCache = false;
 function bridge() {
   return { ios: getIosNative(), android: getAndroidNative() };
@@ -249,6 +259,7 @@ function report(context, cause) {
     onErrorHook?.(context, cause);
   } catch {
   }
+  if (debugLogging) console.warn(`[Advenue] ${context}`, cause);
 }
 function requireStarted() {
   if (started) return true;
@@ -262,6 +273,7 @@ var Advenue = {
    */
   async initialize(config) {
     onErrorHook = config.onError;
+    debugLogging = config.debug === true;
     for (const option of IGNORED_OPTIONS) {
       if (config[option] !== void 0) {
         report(
@@ -280,7 +292,11 @@ var Advenue = {
       signingSecret: config.signingSecret,
       fbAppId: config.fbAppId,
       autoTrackInstall: config.autoTrackInstall !== false,
-      sdkVersion: package_default.version
+      // Names the wrapper, like Flutter's `advenue_sdk/…`: a bare version reads
+      // like the native SDK's own stamp.
+      sdkVersion: `react-native/${package_default.version}`,
+      debug: config.debug === true,
+      allowInsecureHttp: config.allowInsecureHttp === true
     });
     started = true;
     const { ios: iosForErrors, android: androidForErrors } = bridge();

package/dist/index.d.cts

@@ -54,14 +54,12 @@ interface TrackOptions {
 interface AdvenueConfig {
     apiKey: string;
     endpoint?: string;
-    platform?: 'ios' | 'android' | 'web' | string;
     /**
      * @deprecated Ignored: the native SDK resolves the app version from the
      * package/bundle. Passing it reports `config.ignored:appVersion` via
      * `onError`. Removed in the next major.
      */
     appVersion?: string;
-    osVersion?: string;
     /** Gates every event on `setTrackingConsent(true)`. */
     requireConsent?: boolean;
     /** Events per request. */
@@ -74,9 +72,21 @@ interface AdvenueConfig {
      * extracted from it.
      */
     signingSecret?: string;
-    disableAutoSessions?: boolean;
+    /**
+     * **Test only.** Allows an `http://` endpoint — a local self-hosted ingest,
+     * or a test server — which the native SDKs otherwise refuse at initialize.
+     * Never set it in a production build: everything, the API key included,
+     * then travels unencrypted.
+     */
+    allowInsecureHttp?: boolean;
     /** Called when the SDK swallows a best-effort failure. Never receives PII. */
     onError?: (context: string, cause: unknown) => void;
+    /**
+     * Development aid: the native SDKs log their start, every swallowed failure
+     * and each sent batch to Xcode's console / logcat, and every failure is also
+     * written to the JS console as `[Advenue] <context>`. Never logs an
+     * identifier or a payload. Leave off in production; use `onError`.
+     */
     debug?: boolean;
 }
 

package/dist/index.d.ts

@@ -54,14 +54,12 @@ interface TrackOptions {
 interface AdvenueConfig {
     apiKey: string;
     endpoint?: string;
-    platform?: 'ios' | 'android' | 'web' | string;
     /**
      * @deprecated Ignored: the native SDK resolves the app version from the
      * package/bundle. Passing it reports `config.ignored:appVersion` via
      * `onError`. Removed in the next major.
      */
     appVersion?: string;
-    osVersion?: string;
     /** Gates every event on `setTrackingConsent(true)`. */
     requireConsent?: boolean;
     /** Events per request. */
@@ -74,9 +72,21 @@ interface AdvenueConfig {
      * extracted from it.
      */
     signingSecret?: string;
-    disableAutoSessions?: boolean;
+    /**
+     * **Test only.** Allows an `http://` endpoint — a local self-hosted ingest,
+     * or a test server — which the native SDKs otherwise refuse at initialize.
+     * Never set it in a production build: everything, the API key included,
+     * then travels unencrypted.
+     */
+    allowInsecureHttp?: boolean;
     /** Called when the SDK swallows a best-effort failure. Never receives PII. */
     onError?: (context: string, cause: unknown) => void;
+    /**
+     * Development aid: the native SDKs log their start, every swallowed failure
+     * and each sent batch to Xcode's console / logcat, and every failure is also
+     * written to the JS console as `[Advenue] <context>`. Never logs an
+     * identifier or a payload. Leave off in production; use `onError`.
+     */
     debug?: boolean;
 }
 

package/dist/index.js

@@ -54,10 +54,19 @@ var require_native_require = __commonJS({
 // package.json
 var package_default = {
   name: "@advenue/react-native",
-  version: "1.0.1",
+  version: "1.1.1",
   description: "Advenue MMP React Native SDK \u2014 attribution, install tracking, and deep links (bundled iOS/Android Expo native modules)",
   type: "module",
   license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/broverse/advenue.git",
+    directory: "packages/sdk-react-native"
+  },
+  homepage: "https://advenue.io",
+  bugs: {
+    url: "https://github.com/broverse/advenue/issues"
+  },
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
   exports: {
@@ -214,6 +223,7 @@ var started = false;
 var deepLinkSub = null;
 var errorSub = null;
 var onErrorHook;
+var debugLogging = false;
 var consentCache = false;
 function bridge() {
   return { ios: getIosNative(), android: getAndroidNative() };
@@ -238,6 +248,7 @@ function report(context, cause) {
     onErrorHook?.(context, cause);
   } catch {
   }
+  if (debugLogging) console.warn(`[Advenue] ${context}`, cause);
 }
 function requireStarted() {
   if (started) return true;
@@ -251,6 +262,7 @@ var Advenue = {
    */
   async initialize(config) {
     onErrorHook = config.onError;
+    debugLogging = config.debug === true;
     for (const option of IGNORED_OPTIONS) {
       if (config[option] !== void 0) {
         report(
@@ -269,7 +281,11 @@ var Advenue = {
       signingSecret: config.signingSecret,
       fbAppId: config.fbAppId,
       autoTrackInstall: config.autoTrackInstall !== false,
-      sdkVersion: package_default.version
+      // Names the wrapper, like Flutter's `advenue_sdk/…`: a bare version reads
+      // like the native SDK's own stamp.
+      sdkVersion: `react-native/${package_default.version}`,
+      debug: config.debug === true,
+      allowInsecureHttp: config.allowInsecureHttp === true
     });
     started = true;
     const { ios: iosForErrors, android: androidForErrors } = bridge();

package/ios/AdvenueIosModule.swift

@@ -44,11 +44,14 @@ public class AdvenueIosModule: Module {
         },
         // The wrapper's version, not this SDK's: a React Native release pins
         // the native snapshot inside it, so its version identifies both.
-        sdkVersion: options["sdkVersion"] as? String)
+        sdkVersion: options["sdkVersion"] as? String,
+        // Test only; decided at init, where the https precondition runs.
+        allowInsecureHttp: (options["allowInsecureHttp"] as? Bool) ?? false)
       if let flushInterval = options["flushIntervalMs"] as? Int {
         config.flushIntervalMs = flushInterval
       }
       if let batchSize = options["batchSize"] as? Int { config.batchSize = batchSize }
+      config.debug = (options["debug"] as? Bool) ?? false
       Advenue.initialize(config)
       // Firebase App Instance ID, when the host app already ships Firebase.
       // `AdvenueFirebase` guards its import with `#if canImport`, which is