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

package/dist/esm/remoteconfig/fetch.d.ts

@@ -1,24 +1,31 @@
 /**
- * Asks for the rule set, if anything has changed since the last one.
+ * Asks for the rule set: the whole of it with flagtime 0 on the first fetch of a page load, then
+ * only what changed since the last answered request, which is merged into what is stored.
  *
- * Resolves with the parameters as they stand afterwards, whether or not the answer carried a new
- * rule set — an answer with no `remoteconfig` block means nothing has changed, which is the
- * normal case and not a failure.
+ * Resolves with the answer, whether or not it carried a rule set — a later answer with no
+ * `remoteconfig` block means nothing has changed, which is the normal case and not a failure.
  *
- * A second caller joins the first rather than making another request.
+ * With `whole`, a cold fetch: flagtime 0 whatever this page has fetched already, and the answer
+ * replaces the stored set as the first fetch of a page load does.
+ *
+ * A second caller joins the first rather than making another request. A cold fetch joins one
+ * only when it asked with flagtime 0 too, and otherwise asks once it has answered.
  */
-export declare function fetchRemoteConfig(): Promise<Record<string, unknown>>;
+export declare function fetchRemoteConfig(whole?: boolean): Promise<Record<string, unknown>>;
 /**
  * reset(): forgets the rule set, its values and what the server last reported, and disowns a
  * request still in flight, whose answer would otherwise put the old rule set back.
  */
 export declare function resetRemoteConfig(): void;
 /**
- * Makes sure the values are this page's own: from a fetch that just succeeded, or one within
- * CACHE_MS. Resolves true when they are, false when the fetch failed or could not be made — the
- * caller then decides whether stored values will do. Never rejects.
+ * Makes sure the values are this page's own: from a fetch on this page that succeeded, kept up to
+ * date by the polling after it. With `coldFetch`, a fetch with flagtime 0 now, whatever this page
+ * already has, whose answer replaces what is stored: at most COLD_LIMIT a minute, and one past
+ * that answers from what this page has. Resolves true when they are, false when the
+ * fetch failed or could not be made — the caller then decides whether stored values will do.
+ * Never rejects.
  *
  * Waits for start-up and for the device to be registered, which a first visit is still doing
  * when ready() resolves: getupdates is refused without the device ids.
  */
-export declare function obtain(): Promise<boolean>;
+export declare function obtain(coldFetch?: boolean): Promise<boolean>;

package/dist/esm/remoteconfig/fetch.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (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 { SDK_MODULE } from '../core/constants.js';
 import { hooks } from '../core/hooks.js';
 import { _ZAP } from '../core/state.js';
@@ -8,7 +8,7 @@ import { rejectIfOffline, rejectIfNoDeviceIds, postToApptics, apiHeaders } from
 import { deviceReady } from '../device/index.js';
 import { ready } from '../lifecycle.js';
 import { clearCustomConditionValues } from './custom.js';
-import { store, storeUnchanged, flagtime, reresolve, clearRemoteConfig } from './store.js';
+import { store, merge, storeUnchanged, flagtime, reresolve, clearRemoteConfig } from './store.js';
 
 /**
  * The getupdates call.
@@ -28,15 +28,28 @@ const LABEL = 'AppticsRemoteConfig'; // no i18n
 /** getupdatesobj caps moduleids at nine entries; this SDK asks about one. */
 const MODULES = [Number(SDK_MODULE.REMOTE_CONFIG)];
 var inFlight = null;
+/** Whether the request in flight asked with flagtime 0, which a cold fetch can join. */
+var inFlightWhole = false;
 /** Bumped by reset(); an answer to a request made before it is not stored. */
 var generation = 0;
 /**
- * How long a fetch that succeeded on this page answers for later ones, as on Android: a value
- * read on every render must not be a request on every render.
+ * When getupdates is asked again, after the first of a page load: every POLL_MS. Coming back to
+ * the tab asks nothing; the poll's timer carries on. fetchValue() and fetchValues() never ask
+ * themselves once a fetch has succeeded: a value read on every render must not be a request on
+ * every render.
  */
-const CACHE_MS = 5 * 60 * 1000;
-/** When a fetch on this page last succeeded; 0 until one has. */
+const POLL_MS = 3 * 60 * 1000;
+/**
+ * coldFetch goes to the network every time, so it is limited: three in any minute, as on Android.
+ * One past that is answered from the values this page already has.
+ */
+const COLD_LIMIT = 3;
+const COLD_WINDOW_MS = 60 * 1000;
+/** When a fetch on this page last succeeded; 0 until one has, and the next one sends flagtime 0. */
 var fetchedAt = 0;
+/** When the coldFetch calls of the last minute went out. */
+var coldCalls = [];
+var pollTimer = null;
 /**
  * Whether remote config is still worth asking about.
  *
@@ -56,11 +69,11 @@ function wanted() {
  * id for "macOS 15", not the small int this template types. languagecode is sent when there is
  * one, since safe_string cannot match an empty string.
  */
-function body() {
+function body(since) {
     var payload = {
         appversionid: String(_ZAP._device_info.appversionid || ''), // no i18n
         moduleids: MODULES,
-        flagtime: flagtime(),
+        flagtime: since,
     };
     var language = String(navigator.language || '').slice(0, 10); // no i18n
     if (language !== '') {
@@ -73,6 +86,9 @@ function body() {
  *
  * Only to stop asking: getsdkconfig decides whether the feature is on. A module reported off
  * here is dropped from the next request, which is what the API asks for.
+ *
+ * A report that differs from the last one (on until one says otherwise) means the server's
+ * settings changed, so getsdkconfig, which decides, is asked now rather than at its next check.
  */
 function applyReportedModules(data) {
     var status = data.tracking_status;
@@ -81,20 +97,35 @@ function applyReportedModules(data) {
     }
     var entry = status[SDK_MODULE.REMOTE_CONFIG];
     if (entry && typeof entry === 'object') {
-        _ZAP._remoteConfigReported = entry.enabled !== false;
+        var reported = entry.enabled !== false;
+        var changed = reported !== _ZAP._remoteConfigReported;
+        _ZAP._remoteConfigReported = reported;
+        if (changed) {
+            Console.log(LABEL + ': getupdates reported the module ' + (reported ? 'on' : 'off') + ', asking getsdkconfig'); // no i18n
+            hooks.askServerSettings();
+        }
     }
 }
 /**
- * Asks for the rule set, if anything has changed since the last one.
+ * Asks for the rule set: the whole of it with flagtime 0 on the first fetch of a page load, then
+ * only what changed since the last answered request, which is merged into what is stored.
+ *
+ * Resolves with the answer, whether or not it carried a rule set — a later answer with no
+ * `remoteconfig` block means nothing has changed, which is the normal case and not a failure.
  *
- * Resolves with the parameters as they stand afterwards, whether or not the answer carried a new
- * rule set — an answer with no `remoteconfig` block means nothing has changed, which is the
- * normal case and not a failure.
+ * With `whole`, a cold fetch: flagtime 0 whatever this page has fetched already, and the answer
+ * replaces the stored set as the first fetch of a page load does.
  *
- * A second caller joins the first rather than making another request.
+ * A second caller joins the first rather than making another request. A cold fetch joins one
+ * only when it asked with flagtime 0 too, and otherwise asks once it has answered.
  */
-function fetchRemoteConfig() {
+function fetchRemoteConfig(whole) {
     if (inFlight !== null) {
+        if (whole === true && !inFlightWhole) {
+            return inFlight.catch(function () { return {}; }).then(function () {
+                return fetchRemoteConfig(true);
+            });
+        }
         return inFlight;
     }
     if (!wanted()) {
@@ -106,7 +137,11 @@ function fetchRemoteConfig() {
         return blocked;
     }
     var asked = generation;
-    var request = postToApptics('getupdates', body(), apiHeaders(), LABEL).then(function (result) {
+    // the first fetch of the page asks for everything; the stored set is a previous visit's
+    var askWhole = whole === true || fetchedAt === 0;
+    var since = askWhole ? 0 : flagtime();
+    var askedAt = nowMs();
+    var request = postToApptics('getupdates', body(since), apiHeaders(), LABEL).then(function (result) {
         var data = (result.data || {});
         if (asked !== generation) {
             // asked before a reset(): the answer is about the device and app that were just forgotten
@@ -114,15 +149,18 @@ function fetchRemoteConfig() {
         }
         applyReportedModules(data);
         var rules = data.remoteconfig;
-        var at = nowMs();
-        fetchedAt = at;
-        if (rules && typeof rules === 'object') {
-            store(rules, at);
+        fetchedAt = nowMs();
+        if (askWhole) {
+            // with flagtime 0 the answer is the whole set, and no block means there is nothing in it
+            store(rules && typeof rules === 'object' ? rules : {}, askedAt);
+        }
+        else if (rules && typeof rules === 'object') {
+            merge(rules, askedAt);
         }
         else {
             // nothing has changed since our flagtime, which is the answer most of the time
-            storeUnchanged(at);
-            Console.log(LABEL + ': no changes since ' + flagtime()); // no i18n
+            storeUnchanged(askedAt);
+            Console.log(LABEL + ': no changes since ' + since); // no i18n
         }
         return data;
     }).then(function (data) {
@@ -132,13 +170,19 @@ function fetchRemoteConfig() {
         settle();
         return Promise.reject(err);
     });
-    // a request reset() has disowned must not clear the in-flight slot of one made after it
+    // a request reset() has disowned must not clear the in-flight slot of one made after it, nor
+    // start the polling again
     function settle() {
         if (inFlight === request) {
             inFlight = null;
+            inFlightWhole = false;
+        }
+        if (asked === generation) {
+            schedulePoll();
         }
     }
     inFlight = request;
+    inFlightWhole = askWhole;
     return inFlight;
 }
 /**
@@ -148,30 +192,50 @@ function fetchRemoteConfig() {
 function resetRemoteConfig() {
     generation++;
     inFlight = null;
+    inFlightWhole = false;
     fetchedAt = 0;
+    coldCalls = [];
+    if (pollTimer !== null) {
+        clearTimeout(pollTimer);
+        pollTimer = null;
+    }
     _ZAP._remoteConfigReported = true;
     clearCustomConditionValues();
     clearRemoteConfig();
 }
 /**
- * Makes sure the values are this page's own: from a fetch that just succeeded, or one within
- * CACHE_MS. Resolves true when they are, false when the fetch failed or could not be made — the
- * caller then decides whether stored values will do. Never rejects.
+ * Makes sure the values are this page's own: from a fetch on this page that succeeded, kept up to
+ * date by the polling after it. With `coldFetch`, a fetch with flagtime 0 now, whatever this page
+ * already has, whose answer replaces what is stored: at most COLD_LIMIT a minute, and one past
+ * that answers from what this page has. Resolves true when they are, false when the
+ * fetch failed or could not be made — the caller then decides whether stored values will do.
+ * Never rejects.
  *
  * Waits for start-up and for the device to be registered, which a first visit is still doing
  * when ready() resolves: getupdates is refused without the device ids.
  */
-function obtain() {
+function obtain(coldFetch) {
     return ready().then(function (running) {
         if (!running) {
             return false;
         }
-        var now = nowMs();
-        if (fetchedAt > 0 && now - fetchedAt < CACHE_MS) {
+        var cold = coldFetch === true;
+        if (cold) {
+            var now = nowMs();
+            coldCalls = coldCalls.filter(function (at) { return now - at < COLD_WINDOW_MS; });
+            if (coldCalls.length >= COLD_LIMIT) {
+                Console.warn(LABEL + ': coldFetch is limited to ' + COLD_LIMIT + ' a minute; this one is answered from the values this page has'); // no i18n
+                cold = false;
+            }
+            else {
+                coldCalls.push(now);
+            }
+        }
+        if (fetchedAt > 0 && !cold) {
             return true;
         }
         return deviceReady().then(function () {
-            return fetchRemoteConfig();
+            return fetchRemoteConfig(cold);
         }).then(function () {
             return true;
         }, function (err) {
@@ -180,9 +244,40 @@ function obtain() {
         });
     });
 }
-/** Start-up's own fetch, so values are this session's without the app asking. */
+/** A fetch for the polling: failures are logged, and the next tick tries again. */
+function refresh(reason) {
+    if (!_ZAP._ready) {
+        return;
+    }
+    Console.log(LABEL + ': asking for changes (' + reason + ')'); // no i18n
+    deviceReady().then(function () {
+        return fetchRemoteConfig();
+    }).catch(function (err) {
+        Console.log(LABEL + ': fetch failed: ' + String(err)); // no i18n
+    }).then(keepPolling);
+}
+/**
+ * A fetch that never went out (offline, the device not registered yet, the server switched it
+ * off) schedules nothing itself: the polling carries on regardless, so it picks up again.
+ */
+function keepPolling() {
+    if (_ZAP._ready && pollTimer === null && inFlight === null) {
+        schedulePoll();
+    }
+}
+/** The next poll, POLL_MS after the last fetch settled, answered or not. */
+function schedulePoll() {
+    if (pollTimer !== null) {
+        clearTimeout(pollTimer);
+    }
+    pollTimer = setTimeout(function () {
+        pollTimer = null;
+        refresh('every ' + POLL_MS + ' ms'); // no i18n
+    }, POLL_MS);
+}
+/** Start-up's own fetch, so values are this session's without the app asking, then the polling. */
 function fetchOnStart() {
-    obtain();
+    obtain().then(keepPolling);
 }
 hooks.resetRemoteConfig = resetRemoteConfig;
 hooks.remoteConfigStarted = fetchOnStart;

package/dist/esm/remoteconfig/index.d.ts

@@ -1,10 +1,19 @@
 /** AppticsRemoteConfig: fetchValue, fetchValues and setCustomConditionValue, each with the parameter names the console shows. */
 export declare const AppticsRemoteConfig: {
-    fetchValue: (name: string, callback?: (value: string | null) => void) => Promise<string | null>;
-    /** The parameters named, or every parameter when none are: name -> value, null when there is none. */
+    /** One parameter's value, null when there is none. coldFetch (false by default) asks the server for the whole set now. */
+    fetchValue: {
+        (name: string, callback?: (value: string | null) => void, coldFetch?: boolean): Promise<string | null>;
+        (name: string, coldFetch: boolean): Promise<string | null>;
+    };
+    /**
+     * The parameters named, or every parameter when none are: name -> value, null when there is
+     * none. coldFetch (false by default) asks the server for the whole set now.
+     */
     fetchValues: {
-        (names?: string[], callback?: (values: Record<string, string | null>) => void): Promise<Record<string, string | null>>;
-        (callback: (values: Record<string, string | null>) => void): Promise<Record<string, string | null>>;
+        (names?: string[], callback?: (values: Record<string, string | null>) => void, coldFetch?: boolean): Promise<Record<string, string | null>>;
+        (names: string[], coldFetch: boolean): Promise<Record<string, string | null>>;
+        (callback: (values: Record<string, string | null>) => void, coldFetch?: boolean): Promise<Record<string, string | null>>;
+        (coldFetch: boolean): Promise<Record<string, string | null>>;
     };
     /**
      * What this device is for a custom condition, by the condition's name, as comma separated

package/dist/esm/remoteconfig/index.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (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 { forward, guard } from '../core/guard.js';
 import { Console } from '../core/logger.js';
 import { obtain } from './fetch.js';
@@ -13,9 +13,11 @@ import { all } from './store.js';
  * parameter the console has. Each parameter's value is the console's: the value of the first
  * condition, in the console's order, that this device matches, else the parameter's default value.
  * setCustomConditionValue(conditionname, 'a,b') answers the custom conditions.
- * The rule set is stored and resolved on the device, so a fetch within five minutes answers without
- * waiting on the network, and a failed one answers with the values fetched before. The SDK fetches
- * on start-up, and re-applies the rules on its own when AppticsUser.setUser changes the user.
+ * The rule set is stored and resolved on the device, so a read answers without waiting on the
+ * network, and a failed fetch answers with the values fetched before. The SDK fetches the whole set
+ * on start-up, then what changed every 3 minutes; coldFetch (true as
+ * the last argument) asks for the whole set now. It re-applies the rules on its own when
+ * AppticsUser.setUser changes the user.
  *
  * A name the console does not have is null, never undefined: a config system whose failure mode
  * is `undefined` moves the problem into the app's rendering code.
@@ -39,27 +41,37 @@ function answer(value, callback) {
 /**
  * One parameter, fetched for this page, as Android's fetchValue: resolves with its value, or null
  * when the console has no such parameter. A failed fetch answers with the value fetched before.
+ *
+ * `coldFetch` (false by default) asks the server now with flagtime 0, for the whole set, and
+ * answers from that instead of what this page already has. It may come in place of the callback.
  */
-function fetchValue(name, callback) {
-    return obtain().then(function () {
+function fetchValue(name, callback, coldFetch) {
+    if (typeof callback === 'boolean') { // no i18n
+        // fetchValue(name, coldFetch)
+        coldFetch = callback;
+        callback = undefined;
+    }
+    var done = typeof callback === 'function' ? callback : undefined; // no i18n
+    return obtain(coldFetch === true).then(function () {
         var value = raw(name);
-        return answer(value === undefined ? null : value, callback);
+        return answer(value === undefined ? null : value, done);
     });
 }
 /**
  * Several parameters at once: `names` lists the ones wanted, and the result has exactly those
  * names, null for one the console does not have. With no names (or an empty list), every
- * parameter the console has. A callback may come first when there are no names.
+ * parameter the console has. A callback may come first when there are no names, and `coldFetch`
+ * (false by default, as for fetchValue) last, in place of either.
  */
-function fetchValues(names, callback) {
-    if (typeof names === 'function') { // no i18n
-        // fetchValues(callback)
-        callback = names;
-        names = undefined;
-    }
-    var wanted = wantedNames(names);
-    var done = typeof callback === 'function' ? callback : undefined; // no i18n
-    return obtain().then(function () {
+function fetchValues(names, callback, coldFetch) {
+    var args = [names, callback, coldFetch];
+    // the first boolean is coldFetch, wherever it comes: fetchValues(true), fetchValues(names, true),
+    // fetchValues(callback, true)
+    var flag = args.filter(function (one) { return typeof one === 'boolean'; })[0]; // no i18n
+    var fn = args.filter(function (one) { return typeof one === 'function'; })[0]; // no i18n
+    var wanted = wantedNames(typeof names === 'boolean' || typeof names === 'function' ? undefined : names); // no i18n
+    var done = fn;
+    return obtain(flag === true).then(function () {
         var values = all();
         var out = {};
         (wanted === null ? Object.keys(values) : wanted).forEach(function (name) {
@@ -92,11 +104,15 @@ const fetchValuesGuarded = guard('AppticsRemoteConfig.fetchValues', fetchValues)
 const setCustomConditionValueGuarded = guard('AppticsRemoteConfig.setCustomConditionValue', setCustomConditionValue); // no i18n
 /** AppticsRemoteConfig: fetchValue, fetchValues and setCustomConditionValue, each with the parameter names the console shows. */
 const AppticsRemoteConfig = {
-    fetchValue: function fetchValue(name, callback) {
+    /** One parameter's value, null when there is none. coldFetch (false by default) asks the server for the whole set now. */
+    fetchValue: function fetchValue(name, callback, coldFetch) {
         return forward(fetchValueGuarded, arguments);
     },
-    /** The parameters named, or every parameter when none are: name -> value, null when there is none. */
-    fetchValues: function fetchValues(names, callback) {
+    /**
+     * The parameters named, or every parameter when none are: name -> value, null when there is
+     * none. coldFetch (false by default) asks the server for the whole set now.
+     */
+    fetchValues: function fetchValues(names, callback, coldFetch) {
         return forward(fetchValuesGuarded, arguments);
     }, // no i18n
     /**

package/dist/esm/remoteconfig/store.d.ts

@@ -1,17 +1,25 @@
 import type { Dict } from '../types.js';
-/** The flagtime to send: 0 until we hold a rule set, which asks the server for everything. */
+/** When the last answered getupdates went out; 0 when nothing is stored. */
 export declare function flagtime(): number;
 /** Re-resolves the stored rules against this device, without fetching. */
 export declare function reresolve(): void;
-/** Stores a rule set the server just sent, and resolves it. */
-export declare function store(rules: Dict, at: number): void;
 /**
- * Records a fetch that brought no rule set.
+ * Stores a whole rule set, the answer to flagtime 0, in place of what was stored, and resolves
+ * it. `askedAt` is when the request went out: the next one asks for what changed since then.
+ */
+export declare function store(rules: Dict, askedAt: number): void;
+/**
+ * Merges what a later getupdates sent, everything added or changed since its flagtime, into the
+ * stored rule set, and resolves the result. With nothing stored, it is the whole set.
+ */
+export declare function merge(changes: Dict, askedAt: number): void;
+/**
+ * Records a later fetch that brought no changes.
  *
- * That is the normal answer when nothing has changed, and it is not a failure: what is stored
- * stays, and only the fetch time moves.
+ * That is the normal answer, and it is not a failure: what is stored stays, and the next request
+ * asks for what changed since this one went out.
  */
-export declare function storeUnchanged(at: number): void;
+export declare function storeUnchanged(askedAt: number): void;
 /** Forgets the rule set and its values, so the next fetch asks with flagtime 0. */
 export declare function clearRemoteConfig(): void;
 /** Every parameter resolved for this device. Loads from storage on the first read. */

package/dist/esm/remoteconfig/store.js

@@ -1,19 +1,20 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (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 '../core/logger.js';
 import { user_defaults } from '../core/storage.js';
+import { nowMs } from '../core/utils.js';
 import { resolveAll, resetEvaluationWarnings } from './evaluate.js';
 
 /**
  * What remote config keeps between visits.
  *
- * The rule set is stored, not just the resolved values, for two reasons. The server only resends
- * it when something changed — a fetch with a non-zero `flagtime` and no changes answers with no
- * `remoteconfig` block at all — so throwing it away would mean asking for it again with
- * flagtime 0 on every visit. And the resolved values depend on the device: an app version or a
- * customer group that changed since the last visit has to re-resolve against the same rules.
+ * The rule set is stored, not just the resolved values: the values depend on the device, so an
+ * app version or a customer group that changed has to re-resolve against the same rules, and a
+ * visit that cannot reach the server still has the last visit's values to read.
  *
- * `flagtime` is the whole protocol here: it is the moment this SDK last had a rule set, and
- * sending it back is how the server decides whether anything needs saying.
+ * `flagtime` is the whole protocol here. The first getupdates of a page load sends 0 and gets the
+ * whole rule set, which replaces what is stored. Each later one sends the time the last answered
+ * request went out, and gets only what was added or changed since: those parameters and
+ * conditions are merged into the stored set, and one that did not change is kept as it was.
  */
 const STORE_KEY = 'remoteconfig'; // no i18n
 var values = {};
@@ -22,55 +23,86 @@ function read() {
     var saved = user_defaults.item(STORE_KEY);
     return saved && typeof saved === 'object' ? saved : null;
 }
-/** The flagtime to send: 0 until we hold a rule set, which asks the server for everything. */
+/** When the last answered getupdates went out; 0 when nothing is stored. */
 function flagtime() {
     var saved = read();
     return saved && typeof saved.flagtime === 'number' ? saved.flagtime : 0;
 }
-/**
- * The newest `version[].date` in a rule set, which is what the next fetch sends as flagtime.
- *
- * The array is a publication history and is not promised to be in order, so it is the highest
- * date that matters rather than the first or last entry.
- */
-function publishedAt(rules) {
-    var versions = Array.isArray(rules.version) ? rules.version : [];
-    var newest = 0;
-    versions.forEach(function (one) {
-        var at = Number(one.date);
-        if (isFinite(at) && at > newest) {
-            newest = at;
-        }
-    });
-    return newest;
-}
 /** Re-resolves the stored rules against this device, without fetching. */
 function reresolve() {
     var saved = read();
     values = saved && saved.rules ? resolveAll(saved.rules) : {};
     loaded = true;
 }
-/** Stores a rule set the server just sent, and resolves it. */
-function store(rules, at) {
+/**
+ * Stores a whole rule set, the answer to flagtime 0, in place of what was stored, and resolves
+ * it. `askedAt` is when the request went out: the next one asks for what changed since then.
+ */
+function store(rules, askedAt) {
     resetEvaluationWarnings();
-    var record = { flagtime: publishedAt(rules) || at, rules: rules, fetchedat: at };
+    var record = { flagtime: askedAt, rules: rules, fetchedat: nowMs() };
     user_defaults.add(STORE_KEY, record);
     values = resolveAll(rules);
     loaded = true;
-    Console.log('AppticsRemoteConfig: ' + Object.keys(values).length + ' parameters, published ' + record.flagtime); // no i18n
+    Console.log('AppticsRemoteConfig: ' + Object.keys(values).length + ' parameters, as of ' + askedAt); // no i18n
+}
+/**
+ * `changed` laid over `stored`, matched by `key`: an entry the server resent replaces the one
+ * with the same key, in its place; a new one goes on the end; the rest stay as they were.
+ */
+function mergeList(stored, changed, key) {
+    var out = Array.isArray(stored) ? stored.slice() : [];
+    if (!Array.isArray(changed)) {
+        return out;
+    }
+    changed.forEach(function (entry) {
+        if (!entry || typeof entry !== 'object') {
+            return;
+        }
+        var id = key(entry);
+        var at = id === '' ? -1 : out.findIndex(function (one) { return key(one) === id; });
+        if (at >= 0) {
+            out[at] = entry;
+        }
+        else {
+            out.push(entry);
+        }
+    });
+    return out;
+}
+/** An entry's id, or its name when it has none, as the key to match a resent entry by. */
+function idOr(idKey, nameKey) {
+    return function (entry) {
+        var id = entry[idKey] !== undefined && entry[idKey] !== null ? entry[idKey] : entry[nameKey];
+        return id === undefined || id === null ? '' : String(id); // no i18n
+    };
+}
+/**
+ * Merges what a later getupdates sent, everything added or changed since its flagtime, into the
+ * stored rule set, and resolves the result. With nothing stored, it is the whole set.
+ */
+function merge(changes, askedAt) {
+    var saved = read();
+    var base = saved && saved.rules && typeof saved.rules === 'object' ? saved.rules : {};
+    var rules = Object.assign({}, base, changes);
+    rules.all_parameter = mergeList(base.all_parameter, changes.all_parameter, idOr('paramid', 'paramname')); // no i18n
+    rules.all_condition = mergeList(base.all_condition, changes.all_condition, idOr('conditionid', 'conditionname')); // no i18n
+    rules.version = mergeList(base.version, changes.version, idOr('versionid', 'date')); // no i18n
+    store(rules, askedAt);
 }
 /**
- * Records a fetch that brought no rule set.
+ * Records a later fetch that brought no changes.
  *
- * That is the normal answer when nothing has changed, and it is not a failure: what is stored
- * stays, and only the fetch time moves.
+ * That is the normal answer, and it is not a failure: what is stored stays, and the next request
+ * asks for what changed since this one went out.
  */
-function storeUnchanged(at) {
+function storeUnchanged(askedAt) {
     var saved = read();
     if (saved === null) {
         return;
     }
-    saved.fetchedat = at;
+    saved.flagtime = askedAt;
+    saved.fetchedat = nowMs();
     user_defaults.add(STORE_KEY, saved);
 }
 /** Forgets the rule set and its values, so the next fetch asks with flagtime 0. */
@@ -88,4 +120,4 @@ function all() {
     return values;
 }
 
-export { all, clearRemoteConfig, flagtime, reresolve, store, storeUnchanged };
+export { all, clearRemoteConfig, flagtime, merge, reresolve, store, storeUnchanged };

package/dist/esm/remoteconfig/tz-countries.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 /**
  * The country of every IANA time zone, by its ISO 3166 code: generated by
  * scripts/tz-countries.mjs from tzdata 2026d-rearguard (zone.tab, and the old names its links keep).

package/dist/esm/{core → remotelog}/callsite.d.ts

@@ -1,10 +1,11 @@
 /**
- * Where a log line was raised, for logSDK's `filename` and `linenumber`.
+ * Where in the app an AppticsLogger line was written, for logSDK's `filename`, `linenumber` and
+ * `function`: the Remote Logger page shows each line with them.
  *
  * There is no caller introspection in a browser, so the only way to answer "which line was this"
- * is to throw an Error nobody catches and read its stack. That is cheap enough for a channel that
- * only carries the SDK's own failures, but it is never on the app's path: everything here is
- * wrapped so a stack we cannot parse costs a line its call site and nothing more.
+ * is to make an Error and read its stack, skipping the SDK's own frames. That costs a little on
+ * every line the app logs, and nothing on any other call. Everything here is wrapped so a stack
+ * that cannot be parsed costs a line its call site and nothing more: the line is still logged.
  */
 export interface CallSite {
     /** The script's basename, not its url: logSDK caps filename at 100 characters. */