@advenue/react-native 1.0.0 → 1.1.0

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

@@ -0,0 +1,77 @@
+package io.advenue.core
+
+/**
+ * B1: track properties PII scrubbing (varsayılan-açık) — Swift `PIIScrub`
+ * ile aynı sözleşme. Anahtar-adı tabanlı + değer-örüntü tabanlı eşleşen
+ * değerler gönderilmeden önce kaldırılır; ham değer ağa çıkmaz.
+ */
+internal object PiiScrub {
+  private val blockedKeys: Set<String> = setOf(
+    "email", "emailaddress", "emailadres", "eposta", "mail",
+    "phone", "phonenumber", "mobile", "mobilenumber", "mobil",
+    "telefon", "telefonno", "tel", "telno", "gsm",
+    "firstname", "lastname", "ad", "soyad", "adsoyad", "adisoyadi",
+    "fullname", "namesurname", "isim", "isimsoyisim",
+  )
+
+  private val blockedSubstrings: List<String> = listOf(
+    "email", "phone", "telefon", "soyad", "adsoyad", "firstname", "lastname",
+    "fullname",
+  )
+
+  private val emailRegex =
+    Regex("[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}", RegexOption.IGNORE_CASE)
+
+  private val phoneChars: Set<Char> = "+0123456789 \t.-()".toSet()
+
+  internal fun normalizeKey(key: String): String =
+    key.lowercase().filter { it.isLetterOrDigit() }
+
+  internal fun isSensitiveKey(key: String): Boolean {
+    val normalized = normalizeKey(key)
+    if (blockedKeys.contains(normalized)) return true
+    return blockedSubstrings.any { normalized.contains(it) }
+  }
+
+  /**
+   * Telefon sezgiseli (Swift ile aynı): çapasız alt-dize araması YOK.
+   * Değerin TÜMÜ telefon karakterlerinden oluşmalı ve rakam sayısı
+   * E.164 aralığında (10–15) olmalı.
+   */
+  internal fun looksLikePhone(value: String): Boolean {
+    val trimmed = value.trim()
+    if (trimmed.isEmpty()) return false
+    if (!trimmed.all { phoneChars.contains(it) }) return false
+    val first = trimmed.first()
+    val last = trimmed.last()
+    if (!(first == '+' || first.isDigit()) || !last.isDigit()) return false
+    return trimmed.count { it.isDigit() } in 10..15
+  }
+
+  internal fun isSensitiveValue(value: String): Boolean =
+    emailRegex.containsMatchIn(value) || looksLikePhone(value)
+
+  private fun scrubValue(value: Any?): Any? =
+    when (value) {
+      is String -> if (isSensitiveValue(value)) null else value
+      is Map<*, *> -> {
+        @Suppress("UNCHECKED_CAST")
+        val cleaned = scrub(value as Map<String, Any?>) ?: return null
+        cleaned
+      }
+      is List<*> -> value.mapNotNull { scrubValue(it) }
+      else -> value
+    }
+
+  /** PII taşıyan girdileri kaldırır. Girdi null ise null döner. */
+  internal fun scrub(properties: Map<String, Any?>?): Map<String, Any?>? {
+    if (properties == null) return null
+    val kept = LinkedHashMap<String, Any?>(properties.size)
+    for ((key, value) in properties) {
+      if (isSensitiveKey(key)) continue
+      val cleaned = scrubValue(value) ?: continue
+      kept[key] = cleaned
+    }
+    return kept
+  }
+}

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/Collectors.kt

@@ -103,6 +103,20 @@ internal fun tcfFrom(gdprApplies: Int?, purposeConsents: String?): Map<String, A
  * source is unavailable — a misleading zero is worse than a missing value,
  * because downstream it is indistinguishable from a real measurement.
  */
+/**
+ * The app's own version (`versionName`) for every event's top-level
+ * `appVersion`. Resolved here, never taken from the app: the React Native 0.x
+ * layer filled it this way, and 1.0 relying on the config instead left every
+ * event unversioned (2026-09-19). Null when the package manager can't answer.
+ */
+internal fun readAppVersion(context: Context): String? =
+  runCatching {
+      @Suppress("DEPRECATION")
+      context.packageManager.getPackageInfo(context.packageName, 0).versionName
+    }
+    .getOrNull()
+    ?.takeIf { it.isNotBlank() }
+
 internal fun collectDeviceInfo(context: Context): Map<String, Any?> {
   val map = LinkedHashMap<String, Any?>()
   map["model"] = Build.MODEL

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/InstallScopedStore.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import io.advenue.core.DEVICE_ID_KEY
 import io.advenue.core.INSTALLATION_ID_KEY
 import io.advenue.core.INSTALL_SENT_KEY
+import io.advenue.core.QUEUE_KEY
 import java.io.File
 
 /**
@@ -83,6 +84,10 @@ internal class InstallScopedStore(context: Context) : ScopedStore {
         DEVICE_ID_KEY to "advenue-device-id",
         INSTALLATION_ID_KEY to "advenue-installation-id",
         INSTALL_SENT_KEY to "advenue-install-sent",
+        // B4: kuyruk blob'u (GAID'li olay gövdeleri) yedekten çıkar — geri
+        // yüklenen kuyruk hem PII sızıntısı hem de bayat olay yağmurudur.
+        // Eski SharedPreferences anahtarı ilk okumada migrate edilir.
+        QUEUE_KEY to "advenue-queue",
       )
 
     /** The keys this store owns; everything else belongs in [PreferencesStore]. */

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,7 +65,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "@advenue/react-native",
-  version: "1.0.0",
+  version: "1.1.0",
   description: "Advenue MMP React Native SDK \u2014 attribution, install tracking, and deep links (bundled iOS/Android Expo native modules)",
   type: "module",
   license: "MIT",
@@ -214,11 +214,18 @@ function getLinking() {
 }
 
 // src/index.ts
-var IGNORED_OPTIONS = ["mmkv", "secureStore", "sdkConfigFetcher", "tcfDataCollection"];
+var IGNORED_OPTIONS = [
+  "mmkv",
+  "secureStore",
+  "sdkConfigFetcher",
+  "tcfDataCollection",
+  "appVersion"
+];
 var started = false;
 var deepLinkSub = null;
 var errorSub = null;
 var onErrorHook;
+var debugLogging = false;
 var consentCache = false;
 function bridge() {
   return { ios: getIosNative(), android: getAndroidNative() };
@@ -243,6 +250,7 @@ function report(context, cause) {
     onErrorHook?.(context, cause);
   } catch {
   }
+  if (debugLogging) console.warn(`[Advenue] ${context}`, cause);
 }
 function requireStarted() {
   if (started) return true;
@@ -256,6 +264,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(
@@ -268,14 +277,17 @@ var Advenue = {
     call("bridgeInitialize", {
       apiKey: config.apiKey,
       endpoint: config.endpoint,
-      appVersion: config.appVersion,
       requireConsent: config.requireConsent ?? false,
       batchSize: config.batchSize,
       flushIntervalMs: config.flushIntervalMs,
       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,9 +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. */
@@ -69,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;
 }
 
@@ -80,7 +95,6 @@ type TrackingAuthorizationStatus = 'authorized' | 'denied' | 'restricted' | 'not
 interface BridgeInitOptions {
     apiKey: string;
     endpoint?: string;
-    appVersion?: string;
     requireConsent: boolean;
     batchSize?: number;
     flushIntervalMs?: number;