@zoho_apptics/apptics-js-sdk 2.0.0-beta → 2.0.0-beta.2

package/dist/esm/core/db.js

@@ -1,24 +1,71 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { Console } from './logger.js';
 import { nowMs } from './utils.js';
 
 const DB_NAME = 'apptics'; // no i18n
-// 3 added the heatmaps store. The upgrade only creates stores that are missing, so an existing
-// database keeps everything already queued in it.
-const DB_VERSION = 3;
+// 3 added the heatmaps store. 4 renamed: each record's order key `seq` to `queue`, the logs store
+// to feedbacklogs and consolelogs to remotelogs. Every upgrade keeps what is already queued.
+const DB_VERSION = 4;
 const OPEN_TIMEOUT_MS = 3000;
-const QUEUES = ['engagements', 'errors', 'logs', 'consolelogs', 'heatmaps']; // no i18n
-/** 1.x localStorage keys; also the layout of the localStorage backend. */
+const QUEUES = ['engagements', 'errors', 'feedbacklogs', 'remotelogs', 'heatmaps']; // no i18n
+/** The field, and the index on it, that keeps a queue's records in the order they were added. */
+const QUEUE_KEY = 'queue'; // no i18n
+/** Version 3's names, which the version 4 upgrade moves to the ones above. */
+const OLD_QUEUE_KEY = 'seq'; // no i18n
+const RENAMED_STORES = [['logs', 'feedbacklogs'], ['consolelogs', 'remotelogs']]; // no i18n
+/** The types a feedback entry is stored under: an addFeedbackLog() line, an addDiagnosticsInfo() entry. */
+const FEEDBACK_LOG = 'feedbacklog'; // no i18n
+const FEEDBACK_DIAGNOSTICS = 'feedbackdiagnostics'; // no i18n
+const OLD_FEEDBACK_TYPES = Object.freeze({
+    log: FEEDBACK_LOG, // no i18n
+    diagnostics: FEEDBACK_DIAGNOSTICS, // no i18n
+});
+/** A feedback entry from 1.x or 2.0.0-beta, with the type it is stored under now. */
+function renameFeedbackType(item) {
+    var renamed = item && typeof item.type === 'string' ? OLD_FEEDBACK_TYPES[item.type] : undefined; // no i18n
+    return renamed ? { ...item, type: renamed } : item;
+}
+/** 1.x localStorage keys, read once to bring 1.x data into IndexedDB (see migrateLegacy). */
 const LEGACY_KEYS = Object.freeze({
     settings: 'apptics-device-info', // no i18n
     engagements: 'apptics-engagements-transactions', // no i18n
     errors: 'apptics-errors-transactions', // no i18n
     logs: 'apptics-log-transactions', // no i18n
     consolelogs: 'apptics-consolelog-transactions', // no i18n
-    // not a 1.x key: heatmaps did not exist then. It is here because this map is also the
-    // localStorage backend's layout, so the store needs a name there too
+});
+/** The localStorage backend's layout, for a browser where IndexedDB will not open. */
+const LOCAL_KEYS = Object.freeze({
+    settings: LEGACY_KEYS.settings,
+    engagements: LEGACY_KEYS.engagements,
+    errors: LEGACY_KEYS.errors,
+    feedbacklogs: 'apptics-feedbacklog-transactions', // no i18n
+    remotelogs: 'apptics-remotelog-transactions', // no i18n
     heatmaps: 'apptics-heatmap-transactions', // no i18n
 });
+/**
+ * The localStorage backend once kept these two under the 1.x keys. Moved to the new ones on first
+ * use, feedback types renamed on the way, unless something is already there.
+ */
+function moveRenamedLocalKeys() {
+    [[LEGACY_KEYS.logs, LOCAL_KEYS.feedbacklogs], [LEGACY_KEYS.consolelogs, LOCAL_KEYS.remotelogs]].forEach(function (pair) {
+        try {
+            var from = pair[0];
+            var to = pair[1];
+            var old = localStorage.getItem(from);
+            if (old === null) {
+                return;
+            }
+            if (localStorage.getItem(to) === null) {
+                var items = asList(JSON.parse(old));
+                localStorage.setItem(to, JSON.stringify(to === LOCAL_KEYS.feedbacklogs ? items.map(renameFeedbackType) : items));
+            }
+            localStorage.removeItem(from);
+        }
+        catch (err) {
+            // left where it is; the next load tries again
+        }
+    });
+}
 /** Shape guards shared by both backends and the 1.x migration. */
 function asList(value) {
     return Array.isArray(value) ? value : [];
@@ -46,26 +93,33 @@ function writeJSON(key, value) {
     }
 }
 function createLocalStorageBackend() {
+    moveRenamedLocalKeys();
     return {
         kind: 'localstorage', // no i18n
         loadSettings() {
-            return Promise.resolve(asDict(readJSON(LEGACY_KEYS.settings)));
+            return Promise.resolve(asDict(readJSON(LOCAL_KEYS.settings)));
         },
         putSetting(key, value) {
-            const all = asDict(readJSON(LEGACY_KEYS.settings));
+            const all = asDict(readJSON(LOCAL_KEYS.settings));
             all[key] = value;
-            writeJSON(LEGACY_KEYS.settings, all);
+            writeJSON(LOCAL_KEYS.settings, all);
+            return Promise.resolve();
+        },
+        deleteSetting(key) {
+            const all = asDict(readJSON(LOCAL_KEYS.settings));
+            delete all[key];
+            writeJSON(LOCAL_KEYS.settings, all);
             return Promise.resolve();
         },
         clearSettings() {
-            writeJSON(LEGACY_KEYS.settings, {});
+            writeJSON(LOCAL_KEYS.settings, {});
             return Promise.resolve();
         },
         queueAll(store) {
-            return Promise.resolve(asList(readJSON(LEGACY_KEYS[store])));
+            return Promise.resolve(asList(readJSON(LOCAL_KEYS[store])));
         },
         queuePut(store, items) {
-            const list = asList(readJSON(LEGACY_KEYS[store]));
+            const list = asList(readJSON(LOCAL_KEYS[store]));
             items.forEach(function (item) {
                 const index = list.findIndex(function (existing) { return existing.id === item.id; });
                 if (index === -1) {
@@ -75,32 +129,32 @@ function createLocalStorageBackend() {
                     list[index] = item;
                 }
             });
-            writeJSON(LEGACY_KEYS[store], list);
+            writeJSON(LOCAL_KEYS[store], list);
             return Promise.resolve();
         },
         queueDelete(store, ids) {
-            const remaining = asList(readJSON(LEGACY_KEYS[store])).filter(function (item) {
+            const remaining = asList(readJSON(LOCAL_KEYS[store])).filter(function (item) {
                 return ids.indexOf(item.id) === -1;
             });
-            writeJSON(LEGACY_KEYS[store], remaining);
+            writeJSON(LOCAL_KEYS[store], remaining);
             return Promise.resolve();
         },
         queueClear(store) {
-            writeJSON(LEGACY_KEYS[store], []);
+            writeJSON(LOCAL_KEYS[store], []);
             return Promise.resolve();
         },
     };
 }
-let lastSeq = 0;
+let lastQueue = 0;
 /**
  * Strictly increasing, and time-based so tabs interleave in roughly the right order.
  * Counting up from the last value rather than a counter that wraps keeps insertion order
  * even when a chatty caller adds more than a thousand items inside one millisecond.
  */
-function nextSeq() {
+function nextQueue() {
     const base = nowMs() * 1000;
-    lastSeq = base > lastSeq ? base : lastSeq + 1;
-    return lastSeq;
+    lastQueue = base > lastQueue ? base : lastQueue + 1;
+    return lastQueue;
 }
 function request(req) {
     return new Promise(function (resolve, reject) {
@@ -115,7 +169,21 @@ function completed(tx) {
         tx.onabort = function () { reject(tx.error); };
     });
 }
-/** Puts `item` unless it exists (keepExisting) or replaces it keeping its seq. Runs inside `store`'s transaction. */
+/**
+ * The record's `type` for an item with none of its own: heatmap records carry no type, since
+ * their payload is the item itself and the server takes no extra field. Never undefined.
+ */
+const STORE_TYPES = Object.freeze({
+    engagements: 'engagement', // no i18n
+    errors: 'error', // no i18n
+    feedbacklogs: FEEDBACK_LOG,
+    remotelogs: 'remotelog', // no i18n
+    heatmaps: 'heatmap', // no i18n
+});
+function recordType(storeName, item) {
+    return item && typeof item.type === 'string' && item.type !== '' ? item.type : (STORE_TYPES[storeName] || storeName); // no i18n
+}
+/** Puts `item` unless it exists (keepExisting) or replaces it keeping its place. Runs inside `store`'s transaction. */
 function putRecord(store, item, keepExisting) {
     const id = String(item.id);
     const lookup = store.get(id);
@@ -124,7 +192,7 @@ function putRecord(store, item, keepExisting) {
         if (existing && keepExisting) {
             return;
         }
-        store.put({ id: id, seq: existing ? existing.seq : nextSeq(), type: item.type, item: item });
+        store.put({ id: id, queue: existing ? existing.queue : nextQueue(), type: recordType(store.name, item), item: item });
     };
 }
 /** Our stores, as created by onupgradeneeded. */
@@ -185,15 +253,7 @@ function openOnce(factory, timeoutMs) {
             return;
         }
         req.onupgradeneeded = function () {
-            const db = req.result;
-            if (!db.objectStoreNames.contains('settings')) { // no i18n
-                db.createObjectStore('settings'); // no i18n
-            }
-            QUEUES.forEach(function (name) {
-                if (!db.objectStoreNames.contains(name)) {
-                    db.createObjectStore(name, { keyPath: 'id' }).createIndex('seq', 'seq'); // no i18n
-                }
-            });
+            upgrade(req.result, req.transaction);
         };
         req.onsuccess = function () {
             if (settled) {
@@ -224,6 +284,70 @@ function openOnce(factory, timeoutMs) {
         };
     });
 }
+/**
+ * Creates what is missing and moves version 3's data to version 4's names, inside the upgrade's
+ * own transaction: either the whole upgrade lands, or the database stays at the old version with
+ * everything still in it.
+ */
+function upgrade(db, tx) {
+    if (!db.objectStoreNames.contains('settings')) { // no i18n
+        db.createObjectStore('settings'); // no i18n
+    }
+    QUEUES.forEach(function (name) {
+        if (!db.objectStoreNames.contains(name)) {
+            db.createObjectStore(name, { keyPath: 'id' }).createIndex(QUEUE_KEY, QUEUE_KEY); // no i18n
+        }
+    });
+    // kept stores: the order key is renamed on every record, and the index with it
+    QUEUES.forEach(function (name) {
+        const store = tx.objectStore(name);
+        if (!store.indexNames.contains(OLD_QUEUE_KEY)) {
+            return;
+        }
+        store.deleteIndex(OLD_QUEUE_KEY);
+        if (!store.indexNames.contains(QUEUE_KEY)) {
+            store.createIndex(QUEUE_KEY, QUEUE_KEY);
+        }
+        eachRecord(store, function (record, cursor) {
+            cursor.update(renamedRecord(record, false, name));
+        });
+    });
+    // renamed stores: every record moves to its new store, then the old store goes
+    RENAMED_STORES.forEach(function (pair) {
+        const from = pair[0];
+        const to = pair[1];
+        if (!db.objectStoreNames.contains(from)) {
+            return;
+        }
+        const source = tx.objectStore(from);
+        const target = tx.objectStore(to);
+        eachRecord(source, function (record) {
+            target.put(renamedRecord(record, to === 'feedbacklogs', to)); // no i18n
+        }, function () {
+            db.deleteObjectStore(from);
+        });
+    });
+}
+/** Calls `each` for every record of `store`, then `done`, inside the transaction `store` is in. */
+function eachRecord(store, each, done) {
+    const req = store.openCursor();
+    req.onsuccess = function () {
+        const cursor = req.result;
+        if (!cursor) {
+            if (done)
+                done();
+            return;
+        }
+        each(cursor.value, cursor);
+        cursor.continue();
+    };
+}
+/** A version 3 record under version 4's names: `queue` for `seq`, and the feedback types renamed. */
+function renamedRecord(record, feedback, storeName) {
+    const queue = typeof record[QUEUE_KEY] === 'number' ? record[QUEUE_KEY] : (typeof record[OLD_QUEUE_KEY] === 'number' ? record[OLD_QUEUE_KEY] : nextQueue()); // no i18n
+    const item = (feedback ? renameFeedbackType(record.item) : record.item);
+    return { id: String(record.id), queue: queue, type: recordType(storeName, item), item: item };
+}
 function createIndexedDBBackend(db) {
     return {
         kind: 'indexeddb', // no i18n
@@ -242,13 +366,18 @@ function createIndexedDBBackend(db) {
             tx.objectStore('settings').put(value, key); // no i18n
             return completed(tx);
         },
+        deleteSetting(key) {
+            const tx = db.transaction('settings', 'readwrite'); // no i18n
+            tx.objectStore('settings').delete(key); // no i18n
+            return completed(tx);
+        },
         clearSettings() {
             const tx = db.transaction('settings', 'readwrite'); // no i18n
             tx.objectStore('settings').clear(); // no i18n
             return completed(tx);
         },
         queueAll(store) {
-            const index = db.transaction(store, 'readonly').objectStore(store).index('seq'); // no i18n
+            const index = db.transaction(store, 'readonly').objectStore(store).index(QUEUE_KEY);
             return request(index.getAll()).then(function (records) {
                 return records.map(function (record) { return record.item; });
             });
@@ -321,4 +450,4 @@ function openBackend() {
     return openIndexedDB(factory).then(createIndexedDBBackend, fallback);
 }
 
-export { DB_NAME, DB_VERSION, LEGACY_KEYS, asDict, asList, createIndexedDBBackend, createLocalStorageBackend, openBackend, openIndexedDB };
+export { DB_NAME, DB_VERSION, FEEDBACK_DIAGNOSTICS, FEEDBACK_LOG, LEGACY_KEYS, LOCAL_KEYS, asDict, asList, createIndexedDBBackend, createLocalStorageBackend, openBackend, openIndexedDB, renameFeedbackType };

package/dist/esm/core/debug.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { DEBUG_IDLE_MS } from './constants.js';
 import { _ZAP } from './state.js';
 import { Console } from './logger.js';

package/dist/esm/core/env.d.ts

@@ -1,4 +1,3 @@
-import type { AppticsConfig } from '../types.js';
 export declare function isBlockedWS(ua: string): boolean;
 /** Device RAM as the API wants it ("4 GB"). Chromium only; empty elsewhere. */
 export declare function getRam(): string;
@@ -24,5 +23,3 @@ export declare function getTimeZone(): string;
 export declare function is_apptics_disabled(): boolean;
 /** Pure DNT check (no side effects). consent.hasDoNotTrackEnabled() applies NO_TRACKING. */
 export declare function isDntOn(): boolean;
-/** The console snippet's config (window.appticssettings._defaultoptions), if the page defines one. */
-export declare function getSnippetOptions(): AppticsConfig | undefined;

package/dist/esm/core/env.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { BLOCKED_WS } from './constants.js';
 import { includes } from './utils.js';
 
@@ -240,12 +240,5 @@ function isDntOn() {
         return includes(dntValues, dntValue);
     });
 }
-/** The console snippet's config (window.appticssettings._defaultoptions), if the page defines one. */
-function getSnippetOptions() {
-    if (typeof window === 'undefined' || !window.appticssettings) { // no i18n
-        return undefined;
-    }
-    return window.appticssettings._defaultoptions;
-}
 
-export { getBatteryPercent, getBrowser, getBrowserVersion, getConnectionType, getDevice, getNetworkStatus, getOS, getOrientation, getRam, getReferringURL, getSnippetOptions, getTimeZone, isBlockedWS, isDntOn, is_apptics_disabled };
+export { getBatteryPercent, getBrowser, getBrowserVersion, getConnectionType, getDevice, getNetworkStatus, getOS, getOrientation, getRam, getReferringURL, getTimeZone, isBlockedWS, isDntOn, is_apptics_disabled };

package/dist/esm/core/framework-id.d.ts

@@ -1 +1 @@
-export declare const FRAMEWORK_ID = 5996;
+export declare const FRAMEWORK_ID = 6003;

package/dist/esm/core/framework-id.js

@@ -1,7 +1,7 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 // Generated by scripts/register-version.mjs — do not edit by hand.
 // The framework id Apptics issued for this SDK, from POST /sdk/web/v1/framework/addversion
-// (version 2.0.0-beta, platform Browser). Regenerated on every npm pack.
-const FRAMEWORK_ID = 5996;
+// (version 2.0.0-beta.2, platform Browser). Regenerated on every npm pack.
+const FRAMEWORK_ID = 6003;
 
 export { FRAMEWORK_ID };

package/dist/esm/core/guard.d.ts

@@ -1,2 +1,11 @@
 /** Public calls never throw into the host app, and are buffered until start-up finishes. */
 export declare function guard<F extends (...args: any[]) => any>(name: string, fn: F): F;
+/**
+ * Hands a public call's own `arguments` to its guarded function, exactly as they were given.
+ *
+ * guard() returns a wrapper that takes `...args`, so a browser console shows every public call as
+ * `(...args)`. Each public call is therefore its own function with named parameters, which is what
+ * the console shows, and forwards through this: `arguments` rather than the named parameters, so
+ * a call keeps its argument count (addEvent tells its two forms apart by it).
+ */
+export declare function forward<F extends (...args: any[]) => any>(guarded: F, args: IArguments): ReturnType<F>;

package/dist/esm/core/guard.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { _ZAP } from './state.js';
 import { warnAlways, logFailure } from './logger.js';
 
@@ -8,29 +8,31 @@ import { warnAlways, logFailure } from './logger.js';
  * The two log collectors run now so an entry keeps the time it actually happened.
  */
 const RUN_BEFORE_READY = {
-    'Apptics.init': true, ready: true, reset: true, getUser: true, getTrackingStatus: true, sendFeedback: true,
-    addFeedbackLog: true, addDiagnosticsInfo: true,
-    // a switch, so it takes effect in order with the lines logged after it
-    'AppticsLogger.enable': true, 'AppticsLogger.disable': true, 'AppticsLogger.isEnabled': true,
+    'Apptics.init': true, 'Apptics.ready': true, 'Apptics.reset': true, 'AppticsUser.getUser': true,
+    'AppticsSettings.getTrackingStatus': true, 'AppticsFeedback.sendFeedback': true,
+    'AppticsFeedback.addFeedbackLog': true, 'AppticsFeedback.addDiagnosticsInfo': true,
+    // a switch, which init() must not undo: it keeps what was set when its config has no theme
+    'AppticsFeedback.setFeedbackTheme': true,
     // a switch, and a call that hands back the id endTrackApi needs: neither can wait in a queue
-    'AppticsApiTracker.configure': true, 'AppticsApiTracker.startTrackApi': true,
+    'AppticsApi.configure': true, 'AppticsApi.startTrackApi': true,
     // these wait for ready() themselves, and a queued call would hand back undefined, not a Promise
     'AppticsRemoteConfig.fetchValue': true, 'AppticsRemoteConfig.fetchValues': true,
-    'AppticsRemoteConfig.setFallbackWithOfflineValue': true, 'AppticsRemoteConfig.setCustomConditionValue': true,
-    enableDebug: true, disableDebug: true,
+    'AppticsRemoteConfig.setCustomConditionValue': true,
+    'Apptics.enableDebug': true, 'Apptics.disableDebug': true,
 };
 /**
  * Calls that record or send something, and so are lost when the SDK hasn't started. Calls that only
- * set a switch or read a value (enableDebug, AppticsLogger.enable, addFeedbackLog, getUser, …)
+ * set a switch or read a value (Apptics.enableDebug, AppticsLogger.enable, AppticsFeedback.addFeedbackLog,
+ * AppticsUser.getUser, …)
  * work without Apptics.init() and are not listed.
  */
 const NEEDS_INIT = {
-    'AppticsEvents.addEvent': true, 'AppticsScreenTracker.inScreen': true, 'AppticsScreenTracker.outScreen': true,
-    'AppticsApiTracker.endTrackApi': true, AppticsTrackError: true, AppticsSetUser: true, flush: true,
-    AppticsLogger: true, sendFeedback: true, 'AppticsRemoteConfig.fetchValue': true,
+    'AppticsEvent.addEvent': true, 'AppticsScreen.inScreen': true, 'AppticsScreen.outScreen': true,
+    'AppticsApi.endTrackApi': true, 'AppticsError.trackError': true, 'AppticsUser.setUser': true,
+    'Apptics.flush': true, AppticsLogger: true, 'AppticsFeedback.sendFeedback': true, 'AppticsRemoteConfig.fetchValue': true,
     'AppticsRemoteConfig.fetchValues': true,
 };
-/** How a call is named in a message: `AppticsEvents.addEvent` as it is, `flush` as `apptics.flush`. */
+/** How a call is named in a message: every public call is named after its object, as `AppticsEvent.addEvent`. */
 function publicName(name) {
     return name.indexOf('Apptics') === 0 ? name : 'apptics.' + name; // no i18n
 }
@@ -66,5 +68,16 @@ function guard(name, fn) {
     };
     return guarded;
 }
+/**
+ * Hands a public call's own `arguments` to its guarded function, exactly as they were given.
+ *
+ * guard() returns a wrapper that takes `...args`, so a browser console shows every public call as
+ * `(...args)`. Each public call is therefore its own function with named parameters, which is what
+ * the console shows, and forwards through this: `arguments` rather than the named parameters, so
+ * a call keeps its argument count (addEvent tells its two forms apart by it).
+ */
+function forward(guarded, args) {
+    return guarded.apply(null, Array.prototype.slice.call(args));
+}
 
-export { guard };
+export { forward, guard };

package/dist/esm/core/hooks.d.ts

@@ -1,4 +1,3 @@
-import type { CallSite } from './callsite.js';
 import type { DeviceInfo, ServerResult } from '../types.js';
 /**
  * Late-bound calls from lower modules up to the modules above them (see spec §5). device.ts and
@@ -9,7 +8,6 @@ export declare const hooks: {
     updateDevice: (deviceInfo: DeviceInfo) => Promise<ServerResult>;
     refreshDeviceInfo: () => void;
     /** Set by remotelog/index.ts. Here, not imported, so the logger doesn't depend on the sender. */
-    remoteLog: (module: string, message: unknown, site?: CallSite) => void;
     /**
      * Set by feedback/controls.ts: the user picked in the feedback form, or null for anonymous.
      * Here so transport can read the choice without importing the modal.
@@ -24,7 +22,7 @@ export declare const hooks: {
      */
     sendHeatmaps: (forget?: boolean) => Promise<void>;
     /** Set by heatmap/track.ts, so init() and reset() can switch capture without importing it. */
-    enableHeatmap: (status?: boolean) => void;
+    trackHeatmap: (status?: boolean) => void;
     /** Set by heatmap/track.ts: clears what this visit recorded, so the cap starts again. */
     resetHeatmap: () => void;
     /** Set by remoteconfig/fetch.ts, so reset() can forget the rule set without importing it. */
@@ -36,6 +34,11 @@ export declare const hooks: {
     screenTrackedByApp: () => void;
     /** Set by remoteconfig/fetch.ts: start-up has finished, so remote config fetches its values. */
     remoteConfigStarted: () => void;
-    /** Set by remoteconfig/fetch.ts: AppticsSetUser changed who this is, so conditions on the user re-apply. */
+    /** Set by remoteconfig/fetch.ts: AppticsUser.setUser changed who this is, so conditions on the user re-apply. */
     remoteConfigUserChanged: () => void;
+    /**
+     * Set by device/index.ts: getsdkconfig is asked now, outside its next_check_after. setUser calls
+     * it once a user is registered, and remote config when getupdates reports a module changed.
+     */
+    askServerSettings: () => void;
 };

package/dist/esm/core/hooks.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 /**
  * Late-bound calls from lower modules up to the modules above them (see spec §5). device.ts and
  * remotelog/index.ts assign these when they are evaluated; the defaults only run if that module
@@ -7,15 +7,15 @@
 const hooks = {
     updateDevice: () => Promise.reject('apptics: device module not loaded'), // no i18n
     refreshDeviceInfo: () => { },
-    remoteLog: () => { },
     feedbackUser: () => null,
     sendHeatmaps: () => Promise.resolve(),
-    enableHeatmap: () => { },
+    trackHeatmap: () => { },
     resetHeatmap: () => { },
     resetRemoteConfig: () => { },
     screenTrackedByApp: () => { },
     remoteConfigStarted: () => { },
     remoteConfigUserChanged: () => { },
+    askServerSettings: () => { },
 };
 
 export { hooks };

package/dist/esm/core/locks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Runs `run` while holding the Web Lock `name`, waiting for it if another tab of this site holds
+ * it. Locks are shared by every tab of an origin, which is what keeps two tabs from registering
+ * the same browser twice or overwriting each other's session.
+ *
+ * Without the Web Locks API (older browsers), `run` simply runs, as it did before locks were used.
+ * Not reentrant: `run` must not ask for the same lock again, or it waits for itself.
+ */
+export declare function withLock<T>(name: string, run: () => Promise<T>): Promise<T>;

package/dist/esm/core/locks.js

@@ -0,0 +1,20 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
+/**
+ * Runs `run` while holding the Web Lock `name`, waiting for it if another tab of this site holds
+ * it. Locks are shared by every tab of an origin, which is what keeps two tabs from registering
+ * the same browser twice or overwriting each other's session.
+ *
+ * Without the Web Locks API (older browsers), `run` simply runs, as it did before locks were used.
+ * Not reentrant: `run` must not ask for the same lock again, or it waits for itself.
+ */
+function withLock(name, run) {
+    var locks = typeof navigator !== 'undefined' ? navigator.locks : undefined; // no i18n
+    if (!locks || typeof locks.request !== 'function') { // no i18n
+        return run();
+    }
+    return locks.request('apptics-' + name, function () {
+        return run();
+    });
+}
+
+export { withLock };

package/dist/esm/core/logger.d.ts

@@ -8,9 +8,8 @@ export declare const Console: {
 /** Warnings the integrator must see even with debug off (e.g. missing required config). */
 export declare function warnAlways(...args: unknown[]): void;
 /**
- * A failure inside one of the SDK's own modules: logged to the console as usual, and sent to
- * console/addlog so it can be read back from the Apptics console when the SDK misbehaves in the
- * wild. `module` is one of AP_LOG_MODULE's values. The remote half does nothing until
- * the remotelog module has been loaded and its own switch allows it.
+ * A failure inside one of the SDK's own modules, `module` one of AP_LOG_MODULE's values: said in
+ * the browser console in debug mode. Nothing is sent: the Remote Logger page carries only the
+ * lines an app logs with AppticsLogger.
  */
 export declare function logFailure(module: string, ...args: unknown[]): void;

package/dist/esm/core/logger.js

@@ -1,8 +1,6 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { _ZAP } from './state.js';
-import { hooks } from './hooks.js';
 import { each } from './utils.js';
-import { callSiteFromStack, callSite } from './callsite.js';
 
 const APConsole = typeof console !== 'undefined' ? console : null;
 function gated(method) {
@@ -36,47 +34,13 @@ function warnAlways(...args) {
     if (APConsole)
         APConsole.warn(...args);
 }
-function safeJson(value) {
-    try {
-        return JSON.stringify(value) || String(value);
-    }
-    catch (err) {
-        return String(value);
-    }
-}
 /**
- * A failure inside one of the SDK's own modules: logged to the console as usual, and sent to
- * console/addlog so it can be read back from the Apptics console when the SDK misbehaves in the
- * wild. `module` is one of AP_LOG_MODULE's values. The remote half does nothing until
- * the remotelog module has been loaded and its own switch allows it.
+ * A failure inside one of the SDK's own modules, `module` one of AP_LOG_MODULE's values: said in
+ * the browser console in debug mode. Nothing is sent: the Remote Logger page carries only the
+ * lines an app logs with AppticsLogger.
  */
 function logFailure(module, ...args) {
     Console.error.apply(null, args);
-    hooks.remoteLog(module, args.map(function (arg) {
-        if (arg instanceof Error) {
-            return arg.stack || (arg.name + ': ' + arg.message); // no i18n
-        }
-        return typeof arg === 'string' ? arg : safeJson(arg); // no i18n
-    }).join(' '), siteOf(args)); // no i18n
-}
-/**
- * Where to say the failure happened. An Error knows where it was thrown, which is the place
- * worth reporting; the alternative is where it was caught, which is usually a catch block three
- * modules away. Only a frame we could actually read counts, so an Error with no usable stack
- * falls through to logFailure's own caller.
- */
-function siteOf(args) {
-    for (var i = 0; i < args.length; i++) {
-        var arg = args[i];
-        if (arg instanceof Error) {
-            var thrownAt = callSiteFromStack(arg.stack, 0);
-            if (thrownAt.linenumber > 0) {
-                return thrownAt;
-            }
-        }
-    }
-    // past siteOf and logFailure, to whoever reported the failure
-    return callSite(2);
 }
 
 export { Console, logFailure, warnAlways };

package/dist/esm/core/state.d.ts

@@ -1,5 +1,5 @@
-import { type ApConfig } from './constants.js';
-import type { DeviceInfo, Dict, TrackingStatus, UserInfo } from '../types.js';
+import { type ApConfig, type EngagementType } from './constants.js';
+import type { DeviceInfo, Dict, QuartzSettings, TrackingStatus, UserInfo } from '../types.js';
 /** Runtime state shared by every module (the former `_ZAP` object). */
 export interface State {
     _initialised: boolean;
@@ -19,7 +19,6 @@ export interface State {
     _token: string;
     _frameworkID: number;
     _platform: string;
-    _isanonrequired: boolean;
     _devicestatus: TrackingStatus;
     _uuid: string;
     _apid: string;
@@ -30,9 +29,12 @@ export interface State {
     _current_session: Dict;
     _properties: Dict;
     _ignoreDnt: boolean;
-    _isGlobalErrorTracking: boolean;
     _shouldTrack: boolean;
-    _engagementTracking: boolean;
+    /**
+     * getsdkconfig's engagement modules, one per kind of item, keyed by the item's type: event (5),
+     * api (6), screen (10) and session (11).
+     */
+    _engagementTracking: Record<EngagementType, boolean>;
     _errorTracking: boolean;
     /** getsdkconfig module 18. Heatmap has its own flag in v2; before that it rode engagement. */
     _heatmapTracking: boolean;
@@ -44,7 +46,8 @@ export interface State {
     _remoteConfigReported: boolean;
     /** getsdkconfig module 12. */
     _feedbackEnabled: boolean;
-    _quartzEnabled: boolean;
+    /** getsdkconfig's `quartz` block: screen recording in the feedback form. Off until it says otherwise. */
+    _quartz: QuartzSettings;
     /** Epoch ms getsdkconfig asked us to wait until before asking again. 0 means no answer yet. */
     _nextConfigCheck: number;
     /**