kv-test-lib 3.5.2-rc.1 → 3.5.2-rc.2

package/es5_dist/kochava.js

@@ -104,9 +104,10 @@ import { KochavaMeasurementEvent } from "./measurementEvent";
 export { KochavaMeasurementEventType } from "./measurementEvent";
 export { Product } from "./product";
 import { DEFAULTS } from "./interfaces";
-import { deleteAllPersisted, readAndUpdatePersistedValue, updatePersistedValue, PersistKey, checkDuplicateIdLink, addPersistedIdLinks, checkInstallIdChange, readAndUpdateSessionCount, readAndUpdateDeviceId, readAndUpdateUTM, getItem, configureStorage, checkAndRecordDeviceIdChange, persistSentDeviceIds } from "./browser/persist";
+import { deleteAllPersisted, readAndUpdatePersistedValue, updatePersistedValue, PersistKey, checkDuplicateIdLink, addPersistedIdLinks, checkInstallIdChange, readAndUpdateSessionCount, readAndUpdateUTM, getItem, setItem, configureStorage, checkAndRecordDeviceIdChange, persistSentDeviceIds, hasSyncStorage, getItemSync, setItemSync } from "./browser/persist";
 import * as utils from "./utils/utils";
-import { getPageName } from "./browser/browser";
+import { getPageName, getUrlParameter } from "./browser/browser";
+import { getCookie } from "./browser/cookies";
 import adapter from './adapters/adapter.browser.js';
 import { Product } from "./product";
 configureStorage(adapter);
@@ -115,6 +116,11 @@ var Kochava = /** @class */function () {
     // the constructor
     function Kochava() {
         this.product = Product.measurement;
+        // Readiness barrier for the persisted-identity restore.  Resolves
+        // immediately in synchronous-storage environments (browser) and when the
+        // async restore completes otherwise (React Native).  Assigned in
+        // _resetInstance().
+        this._stateRestored = Promise.resolve();
         this._resetInstance();
         this._jobQueue = new JobQueue();
     }
@@ -198,41 +204,112 @@ var Kochava = /** @class */function () {
       - Optionally enqueues an auto_page.
       - Starts the job queue.
     */
+    /**
+     * Start the SDK.
+     *
+     * Returns a promise that resolves once startup reaches the "started"
+     * milestone — install identity resolved, session/appGuid established, and
+     * kvinit/install kicked off.  It intentionally does NOT wait for
+     * kvinit/install to complete: those retry indefinitely on network failure,
+     * and awaiting them would hang the caller with no connectivity.  Existing
+     * void-context callers are unaffected by the added return value.
+     */
     Kochava.prototype.startWithAppGuid = function (appGuid) {
-        this._startWithAppGuid(appGuid);
+        // shutdown() swaps in the fresh instance synchronously, so by the time this
+        // runs (even on the line right after a shutdown), this._instance is already
+        // the new instance — no serialization needed.  _startWithAppGuid captures it
+        // up front and operates only on that captured reference.
+        return this._startWithAppGuid(appGuid);
     };
     Kochava.prototype._startWithAppGuid = function (appGuid) {
         return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var instance, stateRestored, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
+                        // VALIDATE ELSE RETURN
                         if (!appGuid) {
                             Log.error("Invalid appGuid ".concat(appGuid, ", start failed."));
                             return [2 /*return*/];
                         }
-                        if (!this._instance) this._resetInstance();
-                        if (this._instance.started) {
+                        instance = this._instance;
+                        stateRestored = this._stateRestored;
+                        if (instance.started) {
                             Log.warn("Kochava SDK already started.");
                             return [2 /*return*/];
                         }
-                        Log.diagDebug("Host called API: Start With App Guid ".concat(appGuid));
-                        this._restorePersistedDeviceId();
-                        this._instance.started = true;
-                        return [4 /*yield*/, this._checkFirstLaunchAndMigrate()];
+                        // Kick the install-identity resolution before control returns to the
+                        // caller when restore has already completed (synchronous storage): the
+                        // resolution's synchronous prefix populates kochavaDeviceId in place, so
+                        // getDeviceId() on the caller's very next line is already correct once
+                        // started flips true below.
+                        if (instance.stateRestoredBool) {
+                            this._ensureIdentityResolved(instance).catch(function () {});
+                        }
+                        // Gen4 gate: started flips true synchronously within this call — the
+                        // long-standing contract getDeviceId() is gated on — so the identity
+                        // resolved by the kick above is readable on the caller's very next line.
+                        // (On asynchronous-storage platforms the id resolves during the awaits
+                        // below, matching the current production behavior there.)
+                        instance.started = true;
+                        _c.label = 1;
                     case 1:
-                        _a.sent();
-                        this._initInstance(appGuid);
-                        if (!this._instance.disableAutoPage) this.sendPageEvent();
-                        return [4 /*yield*/, this._checkPersistedState()];
+                        _c.trys.push([1, 3,, 4]);
+                        return [4 /*yield*/, stateRestored];
                     case 2:
-                        _a.sent();
-                        return [4 /*yield*/, this._checkPersistedKvinit()];
+                        _c.sent();
+                        return [3 /*break*/, 4];
                     case 3:
-                        _a.sent();
-                        this._printStartupMsgs(appGuid);
-                        return [4 /*yield*/, this._beginStart()];
+                        _a = _c.sent();
+                        return [3 /*break*/, 4];
                     case 4:
-                        _a.sent();
+                        if (instance.invalidatedBool) {
+                            return [2 /*return*/];
+                        }
+                        _c.label = 5;
+                    case 5:
+                        _c.trys.push([5, 7,, 8]);
+                        return [4 /*yield*/, this._ensureIdentityResolved(instance)];
+                    case 6:
+                        _c.sent();
+                        return [3 /*break*/, 8];
+                    case 7:
+                        _b = _c.sent();
+                        return [3 /*break*/, 8];
+                    case 8:
+                        if (instance.invalidatedBool) {
+                            return [2 /*return*/];
+                        }
+                        // MAIN
+                        Log.diagDebug("Host called API: Start With App Guid ".concat(appGuid));
+                        return [4 /*yield*/, this._checkFirstLaunchAndMigrate(instance)];
+                    case 9:
+                        _c.sent();
+                        if (instance.invalidatedBool) {
+                            return [2 /*return*/];
+                        }
+                        this._initInstance(instance, appGuid);
+                        if (!instance.disableAutoPage) this.sendPageEvent();
+                        return [4 /*yield*/, this._checkPersistedState(instance)];
+                    case 10:
+                        _c.sent();
+                        if (instance.invalidatedBool) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this._checkPersistedKvinit(instance)];
+                    case 11:
+                        _c.sent();
+                        if (instance.invalidatedBool) {
+                            return [2 /*return*/];
+                        }
+                        this._printStartupMsgs(instance, appGuid);
+                        // Kick off the network-dependent startup (kvinit, install, queue) WITHOUT
+                        // awaiting it.  Network completion must not gate this returned promise —
+                        // retries are indefinite, so awaiting would hang a caller with no
+                        // connectivity.
+                        this._beginStart(instance).catch(function (e) {
+                            return Log.error("Error during startup", e);
+                        });
                         return [2 /*return*/];
                 }
             });
@@ -244,31 +321,97 @@ var Kochava = /** @class */function () {
       sdk and job queue.
     */
     Kochava.prototype.shutdown = function (deleteData) {
-        this._shutdown(deleteData);
+        Log.diagDebug("Host called API: Shutdown and ".concat(deleteData ? "delete data" : "keep data"));
+        // Capture the instance being torn down.  In-flight startup continuations
+        // hold this same reference and bail on its invalidatedBool, so swapping
+        // this._instance out from under them below can never strand them on the
+        // fresh instance.
+        var invalidatedInstance = this._instance;
+        if (!invalidatedInstance.started) {
+            Log.warn("SDK already shutdown.");
+        }
+        Log.info("SDK shutting down.");
+        // 1. Invalidate synchronously — every in-flight continuation checks this at
+        //    its next await boundary and exits early (after fulfilling anything it
+        //    owns), so no further side effects occur on this instance.
+        invalidatedInstance.invalidatedBool = true;
+        // 2. Resume/stop long-running work so it observes invalidation promptly
+        //    rather than sitting in a retry sleep.  cancelRetries()/stop() resolve
+        //    the pending wait (they no longer merely clear the timer), so the loop
+        //    wakes, sees invalidatedBool, and returns.
+        Kvinit.cancelRetries();
+        Install.cancelRetries();
+        this._jobQueue.stop();
+        this._jobQueue = new JobQueue();
+        // 3. Swap in a fresh instance synchronously so a start issued on the very
+        //    next line (even without awaiting this shutdown) runs on the new
+        //    instance.  When deleting data on asynchronous storage, gate the fresh
+        //    instance's restore on the clear so it never reads storage mid-wipe.
+        //    On synchronous storage no gate is needed: an adapter exposing the sync
+        //    fast-path is synchronous under the hood, so the wipe has already landed
+        //    by the time deleteAllPersisted() returns.
+        if (deleteData) {
+            Log.debug("Deleting persisted values");
+        }
+        var clearPromise = deleteData ? deleteAllPersisted() : Promise.resolve();
+        this._resetInstance(deleteData && !hasSyncStorage() ? clearPromise : undefined);
+        // 4. Complete asynchronously: after the clear (if any) and a bounded drain
+        //    of the invalidated instance's in-flight work, resolve.
+        return this._completeShutdown(clearPromise);
     };
-    Kochava.prototype._shutdown = function (deleteData) {
+    Kochava.prototype._completeShutdown = function (clearPromise) {
         return __awaiter(this, void 0, void 0, function () {
+            var e_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        Log.diagDebug("Host called API: Shutdown and ".concat(deleteData ? "delete data" : "keep data"));
-                        if (!deleteData) return [3 /*break*/, 2];
-                        Log.debug("Deleting persisted values");
-                        return [4 /*yield*/, deleteAllPersisted()];
+                        _a.trys.push([0, 2,, 3]);
+                        return [4 /*yield*/, clearPromise];
                     case 1:
                         _a.sent();
-                        _a.label = 2;
+                        return [3 /*break*/, 3];
                     case 2:
-                        if (!this._instance.started) {
-                            Log.warn("SDK already shutdown.");
-                        }
-                        Log.info("SDK shutting down.");
-                        Kvinit.cancelRetries();
-                        Install.cancelRetries();
-                        this._jobQueue.stop();
-                        // wipe whatever was previously in the queue
-                        this._jobQueue = new JobQueue();
-                        this._resetInstance();
+                        e_1 = _a.sent();
+                        Log.error("Error deleting persisted values during shutdown", e_1);
+                        return [3 /*break*/, 3];
+                    case 3:
+                        return [4 /*yield*/, this._drainInvalidated()];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Bounded event-loop drain.  After invalidation, yield a few macrotask turns
+    // so in-flight work on the just-invalidated instance resumes (its retry waits
+    // were resolved by cancelRetries()/stop()) and bails before we consider
+    // shutdown complete.  This is best-effort quiescence for callers who await
+    // shutdown, never a correctness dependency: a request already in flight
+    // (bounded by the 20s request timeout) can outlive this window, and the
+    // invalidation checks preceding each side effect are what keep any straggler
+    // harmless.  A fixed hop count means it can never hang.
+    Kochava.prototype._drainInvalidated = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var DRAIN_HOPS, i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        DRAIN_HOPS = 4;
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < DRAIN_HOPS)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                            return setTimeout(resolve, 0);
+                        })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 4:
                         return [2 /*return*/];
                 }
             });
@@ -532,7 +675,7 @@ var Kochava = /** @class */function () {
                         if (!(!sleep && this._instance.sleep)) return [3 /*break*/, 3];
                         // only resume queueing if it was paused
                         this._instance.sleep = sleep;
-                        return [4 /*yield*/, this._beginStart()];
+                        return [4 /*yield*/, this._beginStart(this._instance)];
                     case 2:
                         _a.sent();
                         _a.label = 3;
@@ -545,10 +688,16 @@ var Kochava = /** @class */function () {
     // ============================= =============================== //
     // Unintialized/invalid state.
     // start must be called before these values will be correct.
-    Kochava.prototype._resetInstance = function () {
+    //
+    // gate: when provided (shutdown with deleteData on asynchronous storage), the
+    // fresh instance's restore is deferred until the gate resolves — so restore
+    // never reads storage mid-wipe.
+    Kochava.prototype._resetInstance = function (gate) {
+        var _this = this;
         this._instance = {
             appGuid: "",
             started: false,
+            invalidatedBool: false,
             installStarted: false,
             kvinitDone: false,
             installDone: false,
@@ -572,106 +721,258 @@ var Kochava = /** @class */function () {
             utm: "",
             installCount: 0,
             kochavaDeviceId: "",
+            stateRestoredBool: false,
+            identityResolvedPromise: null,
             kochavaInstallId: "",
             kochavaSessionCount: -1,
             kochavaInstallDate: -1,
             kochavaConfig: undefined
         };
+        // Restore the persisted identity so the resolution waterfall can run on
+        // demand.  Synchronously when the storage adapter supports it (browser) —
+        // a returning device's id is in memory before control returns; async
+        // otherwise (React Native), with start waiting on _stateRestored.  Restore
+        // only reads: a device with no stored identity keeps "" until the identity
+        // is resolved at start (_resolveInstallIdentity).  Under the Gen4 started
+        // gate nothing can observe pre-start state, so the remaining persisted
+        // state loads at start (_checkPersistedState / _checkPersistedKvinit)
+        // exactly as before.  When gated (shutdown+delete on async storage),
+        // restore runs only after the wipe settles — including a failed wipe, in
+        // which case restoring whatever survived is the honest state; a rejected
+        // gate must never leave the instance permanently unrestored.
+        var instance = this._instance;
+        this._stateRestored = gate ? gate.catch(function () {}).then(function () {
+            return _this._restoreState(instance);
+        }) : this._restoreState(instance);
     };
-    Kochava.prototype._initInstance = function (appGuid) {
-        // init instance with defaults
-        this._instance.appGuid = appGuid;
-        this._instance.disableAutoPage = this._instance.disableAutoPage || false;
-        this._instance.useCookies = this._instance.useCookies || false;
-        this._instance.version = Product.measurement.standardVersionInfoString;
-        this._instance.buildDate = Product.measurement.sdkBuildDate;
-        this._instance.kochavaSession = utils.uuidv4().substring(0, 5);
-        this._instance.startTimeMS = utils.getCurrTimeMS();
-        this._instance.retryWaterfall = [7, 30, 300, 1800];
-        this._instance.kochavaConfig = JSON.parse(JSON.stringify(DEFAULTS));
+    // Generate a fresh Kochava device id (kvid).
+    Kochava.prototype._generateDeviceId = function () {
+        var kvId = "KB".concat(utils.getCurrTimeSec(), "T").concat(utils.uuidv4());
+        return kvId.replace(/-/g, "");
     };
-    /*
-      Reads (or generates) the device id directly from localStorage, synchronously,
-      so kochavaDeviceId is populated before started flips true and control returns
-      to the caller.  Bypasses the async StorageAdapter deliberately -- the browser
-      adapter is a zero-logic pass-through to localStorage, so this produces an
-      identical result there, and the try/catch makes environments without
-      window.localStorage (React Native) silently no-op and fall back to the
-      existing async readAndUpdateDeviceId() call in _checkPersistedState().
-    */
-    Kochava.prototype._restorePersistedDeviceId = function () {
-        var _a, _b;
-        try {
-            var ls = window.localStorage;
-            var deviceId = (_a = ls.getItem(PersistKey.DeviceId)) !== null && _a !== void 0 ? _a : "";
-            if (!deviceId) {
-                var kvId = "KB".concat(utils.getCurrTimeSec(), "T").concat(utils.uuidv4());
-                deviceId = kvId.replace(/-/g, "");
-                ls.setItem(PersistKey.DeviceId, deviceId);
+    // Choose the restore path based on the configured storage adapter's
+    // capability.  Sync when available (resolve immediately); async otherwise.
+    Kochava.prototype._restoreState = function (instance) {
+        if (hasSyncStorage()) {
+            try {
+                this._restoreSync(instance);
+                return Promise.resolve();
+            } catch (_a) {
+                // Synchronous storage access threw (e.g. localStorage disabled) —
+                // fall back to the async path rather than leaving state unrestored.
             }
-            var overrideDeviceId = (_b = ls.getItem(PersistKey.OverrideDeviceId)) !== null && _b !== void 0 ? _b : "";
-            this._instance.kochavaDeviceId = overrideDeviceId || deviceId;
-        } catch ( /* no-op in environments without window.localStorage (e.g. React Native) */_c) {/* no-op in environments without window.localStorage (e.g. React Native) */}
+        }
+        return this._restoreAsync(instance);
+    };
+    // Synchronous identity restore through the adapter's sync fast-path.
+    // Pure reads — a device with no stored identity keeps "" until the identity
+    // is resolved on demand (_resolveInstallIdentity).
+    Kochava.prototype._restoreSync = function (instance) {
+        var _a, _b;
+        this._applyRestoredIdentity(instance, (_a = getItemSync(PersistKey.DeviceId)) !== null && _a !== void 0 ? _a : "", (_b = getItemSync(PersistKey.OverrideDeviceId)) !== null && _b !== void 0 ? _b : "");
+    };
+    // Asynchronous identity restore through the abstracted StorageAdapter, which
+    // routes to AsyncStorage on React Native.  Pure reads, as above.
+    Kochava.prototype._restoreAsync = function (instance) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, deviceId, overrideDeviceId;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        return [4 /*yield*/, Promise.all([getItem(PersistKey.DeviceId), getItem(PersistKey.OverrideDeviceId)])];
+                    case 1:
+                        _a = _b.sent(), deviceId = _a[0], overrideDeviceId = _a[1];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        this._applyRestoredIdentity(instance, deviceId !== null && deviceId !== void 0 ? deviceId : "", overrideDeviceId !== null && overrideDeviceId !== void 0 ? overrideDeviceId : "");
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Apply the restored identity to the instance.  Both loaders funnel through
+    // here so the two paths can never drift.
+    Kochava.prototype._applyRestoredIdentity = function (instance, deviceId, overrideDeviceId) {
+        // kochavaDeviceId: server override wins over the stored id.
+        instance.kochavaDeviceId = overrideDeviceId || deviceId;
+        // Restore complete — the identity may now be resolved on demand.
+        instance.stateRestoredBool = true;
+    };
+    // Return this instance's install-identity resolution, creating it on first
+    // demand.  Memoized on the instance so it can never pair with the wrong
+    // lifecycle generation across a shutdown swap.
+    Kochava.prototype._ensureIdentityResolved = function (instance) {
+        if (!instance.identityResolvedPromise) {
+            instance.identityResolvedPromise = this._resolveInstallIdentity(instance);
+        }
+        return instance.identityResolvedPromise;
     };
-    Kochava.prototype._checkFirstLaunchAndMigrate = function () {
+    // Resolve the install identity for this instance.  Precondition: the
+    // persisted-identity restore has completed (callers gate on stateRestoredBool
+    // or await _stateRestored first).
+    //
+    // The waterfall, in order — an id is generated only after every read source
+    // is exhausted, so nothing provisional is ever created, persisted, or shown:
+    //   1. Stored id (already in memory from restore).
+    //   2. Shared cookie (useCookies integrations share one identity across
+    //      subdomains; a fresh subdomain's local storage starts empty while the
+    //      shared cookie already holds the real id — adopting it here is what
+    //      keeps a new subdomain from entrenching a new id and clobbering the
+    //      shared identity).  An id read from local storage still wins over the
+    //      cookie, matching the long-standing storage-before-cookie precedence.
+    //   3. Legacy v2 kv_id (URL parameter or storage), only on a first-ever v3
+    //      launch — the identity half of the v2->v3 migration; the bookkeeping
+    //      half stays in _checkFirstLaunchAndMigrate.
+    //   4. Generate — the one and only generation point, logged as such.
+    //
+    // On synchronous-storage platforms every step through the in-memory
+    // assignment executes synchronously, so a resolution kicked from the
+    // synchronous start path makes getDeviceId() correct on the caller's very
+    // next line.  Cookie and legacy-URL sources are DOM-only and are gated on
+    // the sync fast-path accordingly.
+    Kochava.prototype._resolveInstallIdentity = function (instance) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cookieDeviceId, oldKvId, deviceId, cookieOverrideDeviceId;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // WATERFALL
+                        // 1. stored id
+                        if (!instance.kochavaDeviceId) {
+                            // 2. shared cookie
+                            if (instance.useCookies && hasSyncStorage()) {
+                                try {
+                                    cookieDeviceId = getCookie(PersistKey.DeviceId);
+                                    if (cookieDeviceId) {
+                                        instance.kochavaDeviceId = cookieDeviceId;
+                                        setItemSync(PersistKey.DeviceId, cookieDeviceId);
+                                    }
+                                } catch ( /* sync storage unavailable — fall through */_b) {/* sync storage unavailable — fall through */}
+                            }
+                        }
+                        if (!instance.kochavaDeviceId) {
+                            // 3. legacy v2 kv_id (first-ever v3 launch only; web-legacy sources)
+                            if (hasSyncStorage()) {
+                                try {
+                                    if (!getItemSync(PersistKey.FirstStartDate)) {
+                                        oldKvId = getUrlParameter(PersistKey.OldKvid) || getItemSync(PersistKey.OldKvid);
+                                        if (oldKvId) {
+                                            instance.kochavaDeviceId = oldKvId;
+                                            setItemSync(PersistKey.DeviceId, oldKvId);
+                                        }
+                                    }
+                                } catch ( /* sync storage unavailable — fall through */_c) {/* sync storage unavailable — fall through */}
+                            }
+                        }
+                        if (!!instance.kochavaDeviceId) return [3 /*break*/, 2];
+                        deviceId = this._generateDeviceId();
+                        Log.diagDebug("Generated new kochava device id ".concat(deviceId));
+                        instance.kochavaDeviceId = deviceId;
+                        return [4 /*yield*/, setItem(PersistKey.DeviceId, deviceId)];
+                    case 1:
+                        _a.sent();
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        _a.label = 2;
+                    case 2:
+                        // overrideDeviceId
+                        // ⓘ Adopt the shared cookie override when none is stored locally, so a
+                        //   subdomain that has not yet received the override from kvinit reports
+                        //   consistently with the subdomain that has.
+                        if (instance.useCookies && hasSyncStorage()) {
+                            try {
+                                if (!getItemSync(PersistKey.OverrideDeviceId)) {
+                                    cookieOverrideDeviceId = getCookie(PersistKey.OverrideDeviceId);
+                                    if (cookieOverrideDeviceId) {
+                                        instance.kochavaDeviceId = cookieOverrideDeviceId;
+                                        setItemSync(PersistKey.OverrideDeviceId, cookieOverrideDeviceId);
+                                    }
+                                }
+                            } catch ( /* sync storage unavailable */_d) {/* sync storage unavailable */}
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Kochava.prototype._initInstance = function (instance, appGuid) {
+        // init instance with defaults
+        instance.appGuid = appGuid;
+        instance.disableAutoPage = instance.disableAutoPage || false;
+        instance.useCookies = instance.useCookies || false;
+        instance.version = Product.measurement.standardVersionInfoString;
+        instance.buildDate = Product.measurement.sdkBuildDate;
+        instance.kochavaSession = utils.uuidv4().substring(0, 5);
+        instance.startTimeMS = utils.getCurrTimeMS();
+        instance.retryWaterfall = [7, 30, 300, 1800];
+        instance.kochavaConfig = JSON.parse(JSON.stringify(DEFAULTS));
+    };
+    Kochava.prototype._checkFirstLaunchAndMigrate = function (instance) {
         return __awaiter(this, void 0, void 0, function () {
             var firstLaunchDate, oldKvId;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.FirstStartDate, this._instance.useCookies)];
+                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.FirstStartDate, instance.useCookies)];
                     case 1:
                         firstLaunchDate = _a.sent();
-                        if (!!firstLaunchDate) return [3 /*break*/, 6];
-                        return [4 /*yield*/, updatePersistedValue(PersistKey.FirstStartDate, String(utils.getCurrTimeSec()), this._instance.useCookies)];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (!!firstLaunchDate) return [3 /*break*/, 5];
+                        return [4 /*yield*/, updatePersistedValue(PersistKey.FirstStartDate, String(utils.getCurrTimeSec()), instance.useCookies)];
                     case 2:
                         _a.sent();
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.OldKvid, this._instance.useCookies)];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.OldKvid, instance.useCookies)];
                     case 3:
                         oldKvId = _a.sent();
-                        if (!oldKvId) return [3 /*break*/, 6];
-                        return [4 /*yield*/, updatePersistedValue(PersistKey.DeviceId, oldKvId, this._instance.useCookies)];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (!oldKvId) return [3 /*break*/, 5];
+                        // Identity adoption of the legacy id lives in the resolution waterfall
+                        // (_resolveInstallIdentity), which already ran and wins precedence
+                        // battles (an established cookie identity beats the legacy id).  Here
+                        // migration only records that this device has v2 history, so the
+                        // install is not re-sent.
+                        instance.installDone = true;
+                        return [4 /*yield*/, updatePersistedValue(PersistKey.InstallSentDate, JSON.stringify(utils.getCurrTimeSec()), instance.useCookies)];
                     case 4:
                         _a.sent();
-                        return [4 /*yield*/, updatePersistedValue(PersistKey.InstallSentDate, JSON.stringify(utils.getCurrTimeSec()), this._instance.useCookies)];
+                        _a.label = 5;
                     case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6:
                         return [2 /*return*/];
                 }
             });
         });
     };
-    Kochava.prototype._checkPersistedKvinit = function () {
+    Kochava.prototype._checkPersistedKvinit = function (instance) {
         return __awaiter(this, void 0, void 0, function () {
             var persistedKvinit, persistedKvinitStr, persistedKvinitDateStr, lastKvinitDate, refreshMin;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         persistedKvinit = {};
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.LastKvinit, this._instance.useCookies)];
+                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.LastKvinit, instance.useCookies)];
                     case 1:
                         persistedKvinitStr = _a.sent();
+                        if (instance.invalidatedBool) return [2 /*return*/];
                         if (!persistedKvinitStr) return [3 /*break*/, 3];
                         persistedKvinit = JSON.parse(persistedKvinitStr);
                         if (!persistedKvinit) return [3 /*break*/, 3];
                         // if persisted kvinit, apply it
                         Log.trace("Found persisted kvinit.", persistedKvinit);
-                        return [4 /*yield*/, Kvinit.applyKvinitResp(this._instance, persistedKvinit)];
+                        return [4 /*yield*/, Kvinit.applyKvinitResp(instance, persistedKvinit)];
                     case 2:
                         _a.sent();
-                        Log.trace("KochavaConfig after persistedKvinit:", JSON.parse(JSON.stringify(this._instance.kochavaConfig)));
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        Log.trace("KochavaConfig after persistedKvinit:", JSON.parse(JSON.stringify(instance.kochavaConfig)));
                         _a.label = 3;
                     case 3:
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.KvinitSentDate, this._instance.useCookies)];
+                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.KvinitSentDate, instance.useCookies)];
                     case 4:
                         persistedKvinitDateStr = _a.sent();
                         if (persistedKvinitDateStr) {
                             lastKvinitDate = JSON.parse(persistedKvinitDateStr);
                             if (lastKvinitDate) {
-                                refreshMin = this._instance.kochavaConfig.config.refresh_minimum;
-                                if (utils.getCurrTimeSec() - lastKvinitDate < refreshMin) this._instance.kvinitDone = true;
+                                refreshMin = instance.kochavaConfig.config.refresh_minimum;
+                                if (utils.getCurrTimeSec() - lastKvinitDate < refreshMin) instance.kvinitDone = true;
                             }
                         }
                         return [2 /*return*/];
@@ -679,58 +980,72 @@ var Kochava = /** @class */function () {
             });
         });
     };
-    Kochava.prototype._checkPersistedState = function () {
+    Kochava.prototype._checkPersistedState = function (instance) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, _b, _c, _d, _e, installCountStr, parsedInstallCount;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
+            var rawDeviceId, _a, _b, _c, _d, installCountStr, parsedInstallCount;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
-                        _a = this._instance;
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.InstallSentDate, this._instance.useCookies)];
+                        if (!instance.useCookies) return [3 /*break*/, 3];
+                        return [4 /*yield*/, getItem(PersistKey.DeviceId)];
                     case 1:
-                        _a.installDone = _f.sent().length > 0;
-                        _b = this._instance;
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.InstallId, this._instance.useCookies)];
+                        rawDeviceId = _e.sent() || instance.kochavaDeviceId;
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        return [4 /*yield*/, updatePersistedValue(PersistKey.DeviceId, rawDeviceId, true)];
                     case 2:
-                        _b.kochavaInstallId = _f.sent();
-                        _c = this._instance;
-                        return [4 /*yield*/, readAndUpdateDeviceId(this._instance.useCookies)];
+                        _e.sent();
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        _e.label = 3;
                     case 3:
-                        _c.kochavaDeviceId = _f.sent();
-                        _d = this._instance;
-                        return [4 /*yield*/, readAndUpdateSessionCount(this._instance.useCookies)];
+                        _a = instance;
+                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.InstallSentDate, instance.useCookies)];
                     case 4:
-                        _d.kochavaSessionCount = _f.sent();
-                        _e = this._instance;
-                        return [4 /*yield*/, readAndUpdateUTM(this._instance.appGuid, this._instance.useCookies)];
+                        _a.installDone = _e.sent().length > 0;
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        _b = instance;
+                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.InstallId, instance.useCookies)];
                     case 5:
-                        _e.utm = _f.sent();
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.InstallCount, this._instance.useCookies)];
+                        _b.kochavaInstallId = _e.sent();
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        _c = instance;
+                        return [4 /*yield*/, readAndUpdateSessionCount(instance.useCookies)];
                     case 6:
-                        installCountStr = _f.sent();
+                        _c.kochavaSessionCount = _e.sent();
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        _d = instance;
+                        return [4 /*yield*/, readAndUpdateUTM(instance.appGuid, instance.useCookies)];
+                    case 7:
+                        _d.utm = _e.sent();
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.InstallCount, instance.useCookies)];
+                    case 8:
+                        installCountStr = _e.sent();
                         parsedInstallCount = parseInt(installCountStr, 10);
-                        this._instance.installCount = isNaN(parsedInstallCount) ? 0 : parsedInstallCount;
+                        instance.installCount = isNaN(parsedInstallCount) ? 0 : parsedInstallCount;
                         return [2 /*return*/];
                 }
             });
         });
     };
-    Kochava.prototype._printStartupMsgs = function (appGuid) {
+    Kochava.prototype._printStartupMsgs = function (instance, appGuid) {
         var measurementProduct = Product.measurement;
         Log.diagInfo("Started SDK ".concat(measurementProduct.standardVersionInfoString, "\n      published ").concat(measurementProduct.sdkBuildDate));
         Log.diagInfo("The log level is set to ".concat(Log.getLogLevel()));
-        Log.diagDebug("This ".concat(!this._instance.installDone ? "is" : "is not", " the first tracker SDK launch"));
-        Log.diagDebug("The kochava device id is ".concat(this._instance.kochavaDeviceId));
+        Log.diagDebug("This ".concat(!instance.installDone ? "is" : "is not", " the first tracker SDK launch"));
+        Log.diagDebug("The kochava device id is ".concat(instance.kochavaDeviceId));
         Log.diagDebug("The kochava app GUID provided was ".concat(appGuid));
     };
-    Kochava.prototype._beginStart = function () {
+    Kochava.prototype._beginStart = function (instance) {
         return __awaiter(this, void 0, void 0, function () {
+            var jobQueue;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!!this._instance.kvinitDone) return [3 /*break*/, 2];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        jobQueue = this._jobQueue;
+                        if (!!instance.kvinitDone) return [3 /*break*/, 2];
                         Log.diagDebug("A new kvinit will be sent");
-                        return [4 /*yield*/, this.performNewKvinit()];
+                        return [4 /*yield*/, this.performNewKvinit(instance)];
                     case 1:
                         _a.sent();
                         return [3 /*break*/, 3];
@@ -738,20 +1053,23 @@ var Kochava = /** @class */function () {
                         Log.diagDebug("A new kvinit will not be sent");
                         _a.label = 3;
                     case 3:
-                        return [4 /*yield*/, this.checkResendId()];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        return [4 /*yield*/, this.checkResendId(instance)];
                     case 4:
                         // if the install_id changed and thus a new install must go out
-                        if (_a.sent()) this._instance.installDone = false;
-                        Log.diagDebug("The install ".concat(this._instance.installDone ? "has already" : "has not yet", " been sent"));
-                        if (this._instance.sleep) return [2 /*return*/];
-                        if (!!this._instance.installDone) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.performInstall()];
+                        if (_a.sent()) instance.installDone = false;
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        Log.diagDebug("The install ".concat(instance.installDone ? "has already" : "has not yet", " been sent"));
+                        if (instance.sleep) return [2 /*return*/];
+                        if (!!instance.installDone) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.performInstall(instance)];
                     case 5:
                         _a.sent();
                         _a.label = 6;
                     case 6:
-                        if (!(this._instance.kvinitDone && this._instance.installDone)) return [3 /*break*/, 8];
-                        return [4 /*yield*/, this._jobQueue.start(this._instance)];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (!(instance.kvinitDone && instance.installDone)) return [3 /*break*/, 8];
+                        return [4 /*yield*/, jobQueue.start(instance)];
                     case 7:
                         _a.sent();
                         _a.label = 8;
@@ -761,46 +1079,49 @@ var Kochava = /** @class */function () {
             });
         });
     };
-    Kochava.prototype.performNewKvinit = function () {
+    Kochava.prototype.performNewKvinit = function (instance) {
         return __awaiter(this, void 0, void 0, function () {
             var _a, newKvinit, newKvinitStr;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        _a = this._instance;
-                        return [4 /*yield*/, Kvinit.send(this._instance, this._instance.retryWaterfall)];
+                        _a = instance;
+                        return [4 /*yield*/, Kvinit.send(instance, instance.retryWaterfall)];
                     case 1:
                         _a.kvinitDone = _b.sent();
-                        return [4 /*yield*/, updatePersistedValue(PersistKey.KvinitSentDate, String(utils.getCurrTimeSec()), this._instance.useCookies)];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        return [4 /*yield*/, updatePersistedValue(PersistKey.KvinitSentDate, String(utils.getCurrTimeSec()), instance.useCookies)];
                     case 2:
                         _b.sent();
+                        if (instance.invalidatedBool) return [2 /*return*/];
                         newKvinit = {};
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.LastKvinit, this._instance.useCookies)];
+                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.LastKvinit, instance.useCookies)];
                     case 3:
                         newKvinitStr = _b.sent();
+                        if (instance.invalidatedBool) return [2 /*return*/];
                         if (newKvinitStr) {
                             newKvinit = JSON.parse(newKvinitStr);
                         }
-                        return [4 /*yield*/, Kvinit.applyKvinitResp(this._instance, newKvinit)];
+                        return [4 /*yield*/, Kvinit.applyKvinitResp(instance, newKvinit)];
                     case 4:
                         _b.sent();
-                        Log.trace("KochavaConfig after new Kvinit:", JSON.parse(JSON.stringify(this._instance.kochavaConfig)));
+                        Log.trace("KochavaConfig after new Kvinit:", JSON.parse(JSON.stringify(instance.kochavaConfig)));
                         return [2 /*return*/];
                 }
             });
         });
     };
-    Kochava.prototype.checkResendId = function () {
+    Kochava.prototype.checkResendId = function (instance) {
         return __awaiter(this, void 0, void 0, function () {
             var resendId, needsNewInstall;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         resendId = "";
-                        if (this._instance.kochavaConfig.install) {
-                            resendId = this._instance.kochavaConfig.install.resend_id;
+                        if (instance.kochavaConfig.install) {
+                            resendId = instance.kochavaConfig.install.resend_id;
                         }
-                        return [4 /*yield*/, checkInstallIdChange(resendId, this._instance.useCookies)];
+                        return [4 /*yield*/, checkInstallIdChange(resendId, instance.useCookies)];
                     case 1:
                         needsNewInstall = _a.sent();
                         if (needsNewInstall) {
@@ -811,46 +1132,54 @@ var Kochava = /** @class */function () {
             });
         });
     };
-    Kochava.prototype.performInstall = function () {
+    Kochava.prototype.performInstall = function (instance) {
         return __awaiter(this, void 0, void 0, function () {
-            var request, _a;
+            var jobQueue, request, _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        return [4 /*yield*/, Install.build(this._instance)];
+                        jobQueue = this._jobQueue;
+                        return [4 /*yield*/, Install.build(instance)];
                     case 1:
                         request = _b.sent();
-                        _a = this._instance;
-                        return [4 /*yield*/, Install.send(this._instance, request)];
+                        _a = instance;
+                        return [4 /*yield*/, Install.send(instance, request)];
                     case 2:
                         _a.installDone = _b.sent();
-                        if (!this._instance.installDone) return [2 /*return*/];
+                        if (!instance.installDone) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2 /*return*/];
                         // If the install succeeded, remove all idLink that were passed to it
-                        Install.onSuccess(this._instance);
-                        return [4 /*yield*/, this._jobQueue.persistIdLinkQueue()];
+                        return [4 /*yield*/, Install.onSuccess(instance)];
                     case 3:
+                        // If the install succeeded, remove all idLink that were passed to it
                         _b.sent();
-                        return [4 /*yield*/, this._jobQueue.persistUpdateQueue()];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        return [4 /*yield*/, jobQueue.persistIdLinkQueue()];
                     case 4:
                         _b.sent();
-                        return [4 /*yield*/, this._persistSentCustomDeviceIds()];
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        return [4 /*yield*/, jobQueue.persistUpdateQueue()];
                     case 5:
+                        _b.sent();
+                        if (instance.invalidatedBool) return [2 /*return*/];
+                        return [4 /*yield*/, this._persistSentCustomDeviceIds(instance)];
+                    case 6:
                         _b.sent();
                         return [2 /*return*/];
                 }
             });
         });
     };
-    Kochava.prototype._persistSentCustomDeviceIds = function () {
+    Kochava.prototype._persistSentCustomDeviceIds = function (instance) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
             var allowed, sentIds;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        allowed = (_b = (_a = this._instance.kochavaConfig) === null || _a === void 0 ? void 0 : _a.privacy.allow_custom_ids) !== null && _b !== void 0 ? _b : [];
+                        allowed = (_b = (_a = instance.kochavaConfig) === null || _a === void 0 ? void 0 : _a.privacy.allow_custom_ids) !== null && _b !== void 0 ? _b : [];
                         sentIds = {};
-                        this._instance.customValues.forEach(function (cv) {
+                        instance.customValues.forEach(function (cv) {
                             if (!cv.isDeviceId) return;
                             var key = Object.keys(cv.data)[0];
                             var keyAllowed = false;