@advenue/react-native 0.5.0 → 0.6.1

package/dist/index.cjs

@@ -0,0 +1,762 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/native-require.cjs
+var require_native_require = __commonJS({
+  "src/native-require.cjs"(exports2, module2) {
+    "use strict";
+    module2.exports.requireExpoModulesCore = function requireExpoModulesCore2() {
+      try {
+        return require("expo-modules-core");
+      } catch {
+        return null;
+      }
+    };
+    module2.exports.requireReactNative = function requireReactNative2() {
+      try {
+        return require("react-native");
+      } catch {
+        return null;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Advenue: () => Advenue,
+  applyAppState: () => applyAppState,
+  collectDeviceInfo: () => collectDeviceInfo,
+  createMMKVStorage: () => createMMKVStorage,
+  createSecureStore: () => createSecureStore,
+  getAndroidNative: () => getAndroidNative,
+  getIosNative: () => getIosNative,
+  parseDirectLink: () => parseDirectLink,
+  resolveAdvertisingId: () => resolveAdvertisingId,
+  resolveClipboardMatch: () => resolveClipboardMatch,
+  trackInstall: () => trackInstall
+});
+module.exports = __toCommonJS(index_exports);
+var import_install_referrer = require("@advenue/install-referrer");
+var import_sdk_core = require("@advenue/sdk-core");
+
+// ../shared/src/match-token.ts
+var MATCH_TOKEN_PREFIX = "advmatch:";
+function parseMatchToken(raw) {
+  if (!raw || !raw.startsWith(MATCH_TOKEN_PREFIX)) return null;
+  const id = raw.slice(MATCH_TOKEN_PREFIX.length).trim();
+  return /^[A-Za-z0-9_-]{1,128}$/.test(id) ? id : null;
+}
+
+// ../signing/src/index.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function rotr(x, n) {
+  return x >>> n | x << 32 - n;
+}
+function sha256Bytes(msg) {
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const l = msg.length;
+  const bitLen = l * 8;
+  const withOne = l + 1;
+  const padTo = (56 - withOne % 64 + 64) % 64;
+  const padded = new Uint8Array(withOne + padTo + 8);
+  padded.set(msg);
+  padded[l] = 128;
+  const dv = new DataView(padded.buffer);
+  dv.setUint32(padded.length - 8, Math.floor(bitLen / 4294967296));
+  dv.setUint32(padded.length - 4, bitLen >>> 0);
+  const w = new Uint32Array(64);
+  for (let i = 0; i < padded.length; i += 64) {
+    for (let t = 0; t < 16; t++) w[t] = dv.getUint32(i + t * 4);
+    for (let t = 16; t < 64; t++) {
+      const w15 = w[t - 15];
+      const w2 = w[t - 2];
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+    }
+    let a = h[0];
+    let b = h[1];
+    let c = h[2];
+    let d = h[3];
+    let e = h[4];
+    let f = h[5];
+    let g = h[6];
+    let hh = h[7];
+    for (let t = 0; t < 64; t++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + S1 + ch + K[t] + w[t] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  const out = new Uint8Array(32);
+  const odv = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) odv.setUint32(i * 4, h[i]);
+  return out;
+}
+function toHex(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) s += bytes[i].toString(16).padStart(2, "0");
+  return s;
+}
+var enc = new TextEncoder();
+function sha256Hex(message) {
+  return toHex(sha256Bytes(enc.encode(message)));
+}
+
+// src/deep-links.ts
+function parseDirectLink(url) {
+  let deepLinkValue = "";
+  let params;
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname.replace(/^\/+/, "");
+    const isHttp = parsed.protocol === "http:" || parsed.protocol === "https:";
+    deepLinkValue = isHttp ? path : [parsed.host, path].filter(Boolean).join("/");
+    parsed.searchParams.forEach((v, k) => {
+      params ??= {};
+      params[k] = v;
+    });
+  } catch {
+    deepLinkValue = url;
+  }
+  return {
+    deepLinkValue,
+    ...params ? { params } : {},
+    url,
+    isDeferred: false,
+    isFirstLaunch: false
+  };
+}
+function setupDeepLinks(setup) {
+  const listener = setup.addUrlListener((url) => setup.onDeepLink(parseDirectLink(url)));
+  const ready = (async () => {
+    const initial = await setup.getInitialURL();
+    if (initial) {
+      setup.onDeepLink(parseDirectLink(initial));
+      return;
+    }
+    const deferred = await setup.resolveDeferred();
+    if (deferred?.deepLinkValue) {
+      setup.onDeepLink(deferred);
+    }
+  })();
+  return { remove: () => listener.remove(), ready };
+}
+
+// src/mmkv-storage.ts
+function createMMKVStorage(mmkv) {
+  return {
+    getItem: (key) => mmkv.getString(key) ?? null,
+    setItem: (key, value) => mmkv.set(key, value),
+    removeItem: (key) => mmkv.delete(key)
+  };
+}
+
+// src/native.ts
+var import_native_require = __toESM(require_native_require(), 1);
+function getIosNative() {
+  try {
+    const core = (0, import_native_require.requireExpoModulesCore)();
+    return core ? core.requireNativeModule("AdvenueIos") : null;
+  } catch {
+    return null;
+  }
+}
+function getAndroidNative() {
+  try {
+    const core = (0, import_native_require.requireExpoModulesCore)();
+    return core ? core.requireNativeModule("AdvenueAndroid") : null;
+  } catch {
+    return null;
+  }
+}
+function getPlatformOS() {
+  try {
+    const rn = (0, import_native_require.requireReactNative)();
+    return rn?.Platform.OS ?? null;
+  } catch {
+    return null;
+  }
+}
+function getAppState() {
+  try {
+    const rn = (0, import_native_require.requireReactNative)();
+    return rn?.AppState ?? null;
+  } catch {
+    return null;
+  }
+}
+function getLinking() {
+  try {
+    const rn = (0, import_native_require.requireReactNative)();
+    return rn?.Linking ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/native-storage.ts
+function createNativeStorage(mod) {
+  const m = mod;
+  if (!m || typeof m.storageGetItem !== "function" || typeof m.storageSetItem !== "function" || typeof m.storageRemoveItem !== "function") {
+    return null;
+  }
+  return {
+    getItem: (key) => m.storageGetItem?.(key) ?? null,
+    setItem: (key, value) => m.storageSetItem?.(key, value),
+    removeItem: (key) => m.storageRemoveItem?.(key)
+  };
+}
+function createNativeSecureStore(mod) {
+  const m = mod;
+  if (!m || typeof m.secureGetItem !== "function" || typeof m.secureSetItem !== "function" || typeof m.secureRemoveItem !== "function") {
+    return null;
+  }
+  return {
+    getItemAsync: async (key) => m.secureGetItem?.(key) ?? null,
+    setItemAsync: async (key, value) => m.secureSetItem?.(key, value),
+    deleteItemAsync: async (key) => m.secureRemoveItem?.(key)
+  };
+}
+
+// src/secure-store.ts
+function createSecureStore(secureStore2) {
+  return {
+    getItemAsync: async (key) => await secureStore2.getItemAsync(key) ?? null,
+    setItemAsync: (key, value) => secureStore2.setItemAsync(key, value),
+    ...secureStore2.deleteItemAsync ? {
+      deleteItemAsync: (key) => secureStore2.deleteItemAsync?.(key) ?? Promise.resolve()
+    } : {}
+  };
+}
+
+// src/index.ts
+async function resolveAdvertisingId() {
+  const client = active();
+  const consent = client.getConsentData();
+  if (client.getRequireConsent() && consent == null) {
+    client.setAdvertisingId({});
+    return;
+  }
+  if (consent?.isUserSubjectToGDPR === true && consent.hasConsentForDataUsage !== true) {
+    client.setAdvertisingId({});
+    return;
+  }
+  const ios = getIosNative();
+  if (ios) {
+    const idfa = ios.getTrackingAuthorizationStatus() === "authorized" ? await ios.getAdvertisingId() : null;
+    const vendorId = typeof ios.getIdentifierForVendor === "function" ? ios.getIdentifierForVendor() : null;
+    client.setAdvertisingId({ ...idfa ? { idfa } : {}, ...vendorId ? { vendorId } : {} });
+    return;
+  }
+  const android = getAndroidNative();
+  if (android && typeof android.getAdvertisingId === "function") {
+    const r = await android.getAdvertisingId();
+    const vendorId = typeof android.getAppSetId === "function" ? await android.getAppSetId() : null;
+    const adFields = r ? r.limitAdTracking ? { limitAdTracking: true } : { gaid: r.id } : {};
+    const hasUsableGaid = !!r && !r.limitAdTracking;
+    const rawAndroidId = !hasUsableGaid && typeof android.getAndroidId === "function" ? android.getAndroidId() : null;
+    const androidId = rawAndroidId && /^[0-9a-fA-F]{8,32}$/.test(rawAndroidId) ? rawAndroidId : null;
+    client.setAdvertisingId({
+      ...adFields,
+      ...vendorId ? { vendorId } : {},
+      ...androidId ? { androidId } : {}
+    });
+    return;
+  }
+  client.setAdvertisingId({});
+}
+function collectDeviceInfo(natives) {
+  try {
+    if (natives.platform === "android" && natives.android?.getDeviceInfo) {
+      return natives.android.getDeviceInfo();
+    }
+    if (natives.platform === "ios" && natives.ios?.getDeviceInfo) {
+      return natives.ios.getDeviceInfo();
+    }
+  } catch {
+  }
+  return {};
+}
+async function resolveClipboardMatch() {
+  const client = active();
+  if (client.getRequireConsent() && !client.getTrackingConsent()) return null;
+  const ios = getIosNative();
+  if (!ios || typeof ios.getPasteboardMatchToken !== "function") {
+    return null;
+  }
+  let token;
+  try {
+    token = ios.getPasteboardMatchToken();
+  } catch (err) {
+    reportError("enrich.clipboardMatch", err);
+    return null;
+  }
+  const matchId = parseMatchToken(token);
+  if (!matchId) return null;
+  return client.exchangeClipboardMatch(matchId);
+}
+function applyAppState(client, status) {
+  if (status === "active") {
+    client.notifyAppActive();
+  } else if (status === "background") {
+    client.notifyAppBackground();
+  }
+}
+var instance = null;
+var appStateSub = null;
+var deepLinkSub = null;
+var secureStore = null;
+var installFlagStore = null;
+var INSTALL_SENT_KEY = "advenue.install_sent";
+var installInFlight = false;
+var autoInstallPending = false;
+var autoInstallEnabled = true;
+var configuredAppId = null;
+var configuredApiKey = null;
+var configuredEndpoint = import_sdk_core.DEFAULT_ENDPOINT;
+function active() {
+  if (!instance) {
+    throw new Error("Advenue.initialize() must be called before tracking events.");
+  }
+  return instance;
+}
+function reportError(context, cause) {
+  instance?.report(context, cause);
+}
+function fireAutoInstall() {
+  void trackInstall().catch((err) => reportError("install.auto", err));
+}
+function resolvePlatform(explicit) {
+  if (explicit) {
+    return explicit;
+  }
+  const os = getPlatformOS();
+  if (os === "ios" || os === "android") {
+    return os;
+  }
+  if (os) {
+    return "web";
+  }
+  throw new Error(
+    "Advenue.initialize(): platform could not be detected (react-native unavailable) \u2014 pass platform: 'ios' | 'android' | 'web'."
+  );
+}
+function fireAutoInstallIfPending() {
+  if (!autoInstallPending) {
+    return;
+  }
+  autoInstallPending = false;
+  fireAutoInstall();
+}
+var Advenue = {
+  async initialize(config) {
+    const { mmkv, secureStore: secureMod, onDeepLink, appId, autoTrackInstall, ...rest } = config;
+    autoInstallPending = false;
+    autoInstallEnabled = autoTrackInstall !== false;
+    const platform = resolvePlatform(rest.platform);
+    configuredAppId = appId ?? null;
+    configuredApiKey = config.apiKey;
+    configuredEndpoint = config.endpoint ?? import_sdk_core.DEFAULT_ENDPOINT;
+    appStateSub?.remove();
+    appStateSub = null;
+    deepLinkSub?.remove();
+    deepLinkSub = null;
+    instance?.shutdown();
+    const iosMod = getIosNative();
+    const androidMod = getAndroidNative();
+    const storage = mmkv ? createMMKVStorage(mmkv) : createNativeStorage(iosMod ?? androidMod) ?? new import_sdk_core.MemoryStorage();
+    installFlagStore = storage;
+    secureStore = secureMod ? createSecureStore(secureMod) : createNativeSecureStore(iosMod);
+    const deviceId = rest.deviceId ?? await (0, import_sdk_core.resolveDurableDeviceId)(storage, secureStore ?? void 0);
+    instance = new import_sdk_core.AdvenueClient({ ...rest, platform, deviceId, storage });
+    void resolveAdvertisingId().catch((err) => reportError("enrich.advertisingId", err));
+    const deviceInfo = collectDeviceInfo({
+      platform,
+      ios: getIosNative(),
+      android: getAndroidNative()
+    });
+    if (Object.keys(deviceInfo).length > 0) instance.setDeviceInfo(deviceInfo);
+    if (!config.disableAutoSessions) {
+      const appState = getAppState();
+      if (appState) {
+        appStateSub?.remove();
+        let seenBackground = false;
+        const handler = (status) => {
+          if (!instance) return;
+          if (status === "background") {
+            seenBackground = true;
+            applyAppState(instance, status);
+          } else if (status === "active") {
+            if (!seenBackground) return;
+            seenBackground = false;
+            applyAppState(instance, status);
+            void resolveAdvertisingId().catch((err) => reportError("enrich.advertisingId", err));
+          }
+        };
+        appStateSub = appState.addEventListener("change", handler);
+        instance.notifyAppActive();
+      } else {
+        instance.notifyAppActive();
+      }
+    }
+    if (onDeepLink) {
+      const linking = getLinking();
+      if (linking) {
+        const client = instance;
+        deepLinkSub = setupDeepLinks({
+          getInitialURL: () => linking.getInitialURL(),
+          addUrlListener: (handler) => linking.addEventListener("url", (e) => handler(e.url)),
+          // Deferred waterfall: clipboard (deterministic) first, then the
+          // server-side conversion poll (IDFA / probabilistic).
+          resolveDeferred: async () => await resolveClipboardMatch() ?? client.resolveDeferredDeepLink(),
+          onDeepLink
+        });
+        deepLinkSub.ready.catch((err) => reportError("deepLink.resolve", err));
+      }
+    }
+    if (autoTrackInstall !== false) {
+      if (instance.getRequireConsent() && !instance.getTrackingConsent()) {
+        autoInstallPending = true;
+        instance.debugLog("install deferred until consent is granted");
+      } else {
+        fireAutoInstall();
+      }
+    }
+    return instance;
+  },
+  track: (name, properties, opts) => active().track(name, properties, opts),
+  /**
+   * Shows the iOS ATT prompt (resolves 'authorized' immediately on Android/web,
+   * where ATT doesn't exist) and forwards the result to the consent gate.
+   */
+  async requestTrackingAuthorization() {
+    const ios = getIosNative();
+    const status = ios ? await ios.requestTrackingAuthorization() : "authorized";
+    active().setTrackingConsent(status === "authorized");
+    void resolveAdvertisingId().catch((err) => reportError("enrich.advertisingId", err));
+    if (status === "authorized") {
+      fireAutoInstallIfPending();
+    }
+    return status;
+  },
+  setTrackingConsent(granted) {
+    active().setTrackingConsent(granted);
+    if (granted) {
+      fireAutoInstallIfPending();
+    }
+  },
+  getTrackingConsent: () => active().getTrackingConsent(),
+  /** GDPR/CCPA erasure: stop tracking and wipe local identifiers/queue. */
+  forgetMe() {
+    active().forgetMe();
+    try {
+      installFlagStore?.removeItem(INSTALL_SENT_KEY);
+    } catch (err) {
+      reportError("forget.wipe", err);
+    }
+    const secure = secureStore;
+    if (secure?.deleteItemAsync) {
+      for (const key of [import_sdk_core.DEVICE_ID_KEY, INSTALL_SENT_KEY]) {
+        void secure.deleteItemAsync(key).catch((err) => reportError("forget.secureWipe", err));
+      }
+    }
+  },
+  setConsentData(consent) {
+    active().setConsentData(consent);
+    void resolveAdvertisingId().catch((err) => reportError("enrich.advertisingId", err));
+  },
+  getConsentData: () => active().getConsentData(),
+  flush: () => active().flush(),
+  getDeviceId: () => active().getDeviceId(),
+  shutdown() {
+    appStateSub?.remove();
+    appStateSub = null;
+    deepLinkSub?.remove();
+    deepLinkSub = null;
+    instance?.shutdown();
+    instance = null;
+    secureStore = null;
+    installInFlight = false;
+    autoInstallPending = false;
+    autoInstallEnabled = true;
+    configuredAppId = null;
+    configuredApiKey = null;
+    configuredEndpoint = import_sdk_core.DEFAULT_ENDPOINT;
+  }
+};
+async function trackInstall() {
+  const client = active();
+  if (client.getRequireConsent() && !client.getTrackingConsent()) {
+    return;
+  }
+  let sent = installFlagStore?.getItem(INSTALL_SENT_KEY) === "1";
+  if (!sent && secureStore) {
+    try {
+      sent = await secureStore.getItemAsync(INSTALL_SENT_KEY) === "1";
+    } catch (err) {
+      reportError("install.guardRead", err);
+    }
+  }
+  if (sent) {
+    client.debugLog("install skipped (already sent on this device)");
+    return;
+  }
+  if (installInFlight) {
+    return;
+  }
+  installInFlight = true;
+  const opts = {};
+  const props = {};
+  const android = getAndroidNative();
+  if (android) {
+    try {
+      const result = await android.getInstallReferrer();
+      if (result) {
+        const parsed = (0, import_install_referrer.parseInstallReferrer)(result.referrer);
+        if (parsed.network) opts.network = parsed.network;
+        if (parsed.campaign) opts.campaign = parsed.campaign;
+        if (parsed.gclid) props.gclid = parsed.gclid;
+        if (parsed.fbclid) props.fbclid = parsed.fbclid;
+        Object.assign(props, (0, import_install_referrer.extractReferrerProperties)(result));
+      }
+    } catch (err) {
+      reportError("enrich.installReferrer", err);
+    }
+    try {
+      const meta = await android.getMetaInstallReferrer();
+      const parsedMeta = meta ? (0, import_install_referrer.parseMetaInstallReferrer)(meta) : null;
+      if (parsedMeta) {
+        props.metaInstallReferrer = parsedMeta.raw;
+        if (parsedMeta.encryptedData) props.metaReferrerData = parsedMeta.encryptedData;
+        if (parsedMeta.nonce) props.metaReferrerNonce = parsedMeta.nonce;
+        if (!opts.network && parsedMeta.isClickThrough) {
+          opts.network = "meta";
+          if (parsedMeta.campaign) opts.campaign = parsedMeta.campaign;
+        }
+      }
+    } catch (err) {
+      reportError("enrich.metaReferrer", err);
+    }
+  }
+  const ios = getIosNative();
+  if (ios) {
+    try {
+      ios.registerAppForAttribution();
+    } catch (err) {
+      reportError("enrich.skanRegister", err);
+    }
+    try {
+      const asaToken = await ios.getAttributionToken();
+      if (asaToken) {
+        opts.adservicesToken = asaToken;
+      }
+    } catch (err) {
+      reportError("enrich.adservicesToken", err);
+    }
+  }
+  await resolveAdvertisingId();
+  const trackOpts = { type: "install", ...opts };
+  if (configuredAppId && android && typeof android.getIntegrityToken === "function") {
+    try {
+      const deviceId = client.getDeviceId();
+      const requestHash = sha256Hex(`${configuredAppId}:${deviceId}`);
+      const token = await android.getIntegrityToken(requestHash);
+      if (token) {
+        trackOpts.attestationToken = token;
+        trackOpts.attestationType = "play-integrity";
+      }
+    } catch (err) {
+      reportError("attest.playIntegrity", err);
+    }
+  }
+  if (configuredAppId && configuredApiKey && ios && typeof ios.attestKey === "function") {
+    try {
+      const deviceId = client.getDeviceId();
+      const challengeUrl = `${configuredEndpoint}/v1/attest/challenge?deviceId=${encodeURIComponent(deviceId)}`;
+      const challengeRes = await fetch(challengeUrl, {
+        headers: { "x-api-key": configuredApiKey }
+      });
+      if (!challengeRes.ok) throw new Error(`challenge HTTP ${challengeRes.status}`);
+      const { challenge } = await challengeRes.json();
+      const { keyId, attestationObject } = await ios.attestKey(challenge);
+      trackOpts.attestationToken = attestationObject;
+      trackOpts.attestationType = "app-attest";
+      trackOpts.attestationKeyId = keyId;
+      trackOpts.attestationChallenge = challenge;
+    } catch (err) {
+      reportError("attest.appAttest", err);
+    }
+  }
+  if (ios && typeof ios.getDeviceCheckToken === "function") {
+    try {
+      const token = await ios.getDeviceCheckToken();
+      if (token) {
+        trackOpts.deviceCheckToken = token;
+      }
+    } catch (err) {
+      reportError("attest.deviceCheck", err);
+    }
+  }
+  const pendingBefore = client.pendingCount;
+  client.track("install", props, trackOpts);
+  if (client.pendingCount === pendingBefore) {
+    installInFlight = false;
+    client.debugLog("install dropped (consent revoked mid-flight)");
+    if (autoInstallEnabled && client.getRequireConsent() && !client.getTrackingConsent()) {
+      autoInstallPending = true;
+    }
+    return;
+  }
+  client.debugLog("install fired");
+  try {
+    installFlagStore?.setItem(INSTALL_SENT_KEY, "1");
+  } catch (err) {
+    reportError("install.flagPersist", err);
+  }
+  if (secureStore) {
+    try {
+      await secureStore.setItemAsync(INSTALL_SENT_KEY, "1");
+    } catch (err) {
+      reportError("install.flagPersistSecure", err);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Advenue,
+  applyAppState,
+  collectDeviceInfo,
+  createMMKVStorage,
+  createSecureStore,
+  getAndroidNative,
+  getIosNative,
+  parseDirectLink,
+  resolveAdvertisingId,
+  resolveClipboardMatch,
+  trackInstall
+});