@namiml/sdk-core 3.4.12-dev.202609251647 → 3.4.12-dev.202609281806

package/dist/index.cjs

@@ -106,7 +106,7 @@ const {
 // version — stamped by scripts/version.sh
 NAMI_SDK_VERSION: exports.NAMI_SDK_VERSION = "3.4.12", 
 // full package version including dev suffix — stamped by scripts/version.sh
-NAMI_SDK_PACKAGE_VERSION: exports.NAMI_SDK_PACKAGE_VERSION = "3.4.12-dev.202609251647", 
+NAMI_SDK_PACKAGE_VERSION: exports.NAMI_SDK_PACKAGE_VERSION = "3.4.12-dev.202609281806", 
 // environments
 PRODUCTION: exports.PRODUCTION = "production", DEVELOPMENT: exports.DEVELOPMENT = "development", 
 // error messages
@@ -116,7 +116,25 @@ AUTH_DEVICE: exports.AUTH_DEVICE = "nami_auth_device", NAMI_CONFIGURATION: expor
 // API settings
 API_VERSION: exports.API_VERSION = "v3", BASE_URL_PATH: exports.BASE_URL_PATH = `sdk/${exports.API_VERSION}/platform`, BASE_URL: exports.BASE_URL = "https://app.namiml.com", BASE_STAGING_URL: exports.BASE_STAGING_URL = "https://app-staging.namiml.com", CUSTOM_HOST_PREFIX: exports.CUSTOM_HOST_PREFIX = "namiAPIHost=", USE_STAGING_API: exports.USE_STAGING_API = "useStagingAPI", 
 // // extended client info
-EXTENDED_CLIENT_INFO_PREFIX: exports.EXTENDED_CLIENT_INFO_PREFIX = "extendedClientInfo", EXTENDED_CLIENT_INFO_DELIMITER: exports.EXTENDED_CLIENT_INFO_DELIMITER = ":", VALIDATE_PRODUCT_GROUPS: exports.VALIDATE_PRODUCT_GROUPS = "validateProductGroups", LOG_HTTP_REQUESTS: exports.LOG_HTTP_REQUESTS = "logHTTPRequests", LOG_HTTP_TRAFFIC: exports.LOG_HTTP_TRAFFIC = "logHTTPTraffic", API_TRAFFIC_OBSERVER: exports.API_TRAFFIC_OBSERVER = "apiTrafficObserver", STARTUP_TELEMETRY: exports.STARTUP_TELEMETRY = "startupTelemetry", EXTENDED_PLATFORM: exports.EXTENDED_PLATFORM = "extended-platform", EXTENDED_PLATFORM_VERSION: exports.EXTENDED_PLATFORM_VERSION = "extended-platform-version", API_MAX_CALLS_LIMIT: exports.API_MAX_CALLS_LIMIT = 2, API_RETRY_DELAY_SEC: exports.API_RETRY_DELAY_SEC = 2, API_TIMEOUT_LIMIT: exports.API_TIMEOUT_LIMIT = 20000, DEVICE_API_TIMEOUT_LIMIT: exports.DEVICE_API_TIMEOUT_LIMIT = 2000, 
+EXTENDED_CLIENT_INFO_PREFIX: exports.EXTENDED_CLIENT_INFO_PREFIX = "extendedClientInfo", EXTENDED_CLIENT_INFO_DELIMITER: exports.EXTENDED_CLIENT_INFO_DELIMITER = ":", VALIDATE_PRODUCT_GROUPS: exports.VALIDATE_PRODUCT_GROUPS = "validateProductGroups", LOG_HTTP_REQUESTS: exports.LOG_HTTP_REQUESTS = "logHTTPRequests", LOG_HTTP_TRAFFIC: exports.LOG_HTTP_TRAFFIC = "logHTTPTraffic", API_TRAFFIC_OBSERVER: exports.API_TRAFFIC_OBSERVER = "apiTrafficObserver", STARTUP_TELEMETRY: exports.STARTUP_TELEMETRY = "startupTelemetry", 
+// Test hook: every platform-config fetch attempt fails before the request leaves.
+// Same namiCommand as Apple's and Android's, so the shared first-run flows drive it.
+SIMULATE_CONFIG_FETCH_FAILURE: exports.SIMULATE_CONFIG_FETCH_FAILURE = "simulateConfigFetchFailure", 
+// Test hook: every per-paywall body fetch fails before the request leaves, so the body cache's
+// failure rows can be exercised without a proxy. Same namiCommand as Apple's and Android's (NAM-4357).
+SIMULATE_PAYWALL_FETCH_FAILURE: exports.SIMULATE_PAYWALL_FETCH_FAILURE = "simulatePaywallFetchFailure", 
+// `campaignCacheTTL=<seconds>` overrides the config's campaign_cache_ttl — Apple's command name.
+// It lets the paywall-cache e2e suite pin TTL 3600 / 1 / 0 per load (NAM-4357).
+CAMPAIGN_CACHE_TTL_PREFIX: exports.CAMPAIGN_CACHE_TTL_PREFIX = "campaignCacheTTL=", EXTENDED_PLATFORM: exports.EXTENDED_PLATFORM = "extended-platform", EXTENDED_PLATFORM_VERSION: exports.EXTENDED_PLATFORM_VERSION = "extended-platform-version", API_MAX_CALLS_LIMIT: exports.API_MAX_CALLS_LIMIT = 2, API_RETRY_DELAY_SEC: exports.API_RETRY_DELAY_SEC = 2, API_TIMEOUT_LIMIT: exports.API_TIMEOUT_LIMIT = 20000, DEVICE_API_TIMEOUT_LIMIT: exports.DEVICE_API_TIMEOUT_LIMIT = 2000, 
+// Platform-config attempts when no initial config was supplied (Android's
+// CONFIG_MAX_ATTEMPTS; Apple's retry(maxAttempts: 3)).
+CONFIG_MAX_ATTEMPTS: exports.CONFIG_MAX_ATTEMPTS = 3, 
+// Per-attempt timeout for GET config/. Android's config client allows 5 s to connect plus 5 s
+// to read (Apple allows 30 s); three attempts keep a total outage near 30 s.
+CONFIG_API_TIMEOUT_LIMIT: exports.CONFIG_API_TIMEOUT_LIMIT = 10000, 
+// A foreground within this long of the last launch/resume run is skipped — Apple's
+// NamiStartupCoordinator.shouldRunResume window.
+RESUME_THROTTLE_MS: exports.RESUME_THROTTLE_MS = 30000, 
 // status codes
 STATUS_SUCCESS: exports.STATUS_SUCCESS = 200, STATUS_BAD_REQUEST: exports.STATUS_BAD_REQUEST = 400, STATUS_NOT_FOUND: exports.STATUS_NOT_FOUND = 404, STATUS_CONFLICT: exports.STATUS_CONFLICT = 409, STATUS_INTERNAL_SERVER_ERROR: exports.STATUS_INTERNAL_SERVER_ERROR = 500, 
 // configuration states
@@ -3047,6 +3065,206 @@ function uniqBy(array, iteratee) {
   return (array && array.length) ? baseUniq(array, baseIteratee(iteratee)) : [];
 }
 
+/** Storage key of an entry's raw body; the exact URL follows the prefix. */
+const PAYWALL_BODY_KEY_PREFIX = "api_paywall_body:";
+/**
+ * Storage key of an entry's metadata. Written AFTER the body, so it is the commit point: an entry
+ * is visible only once both are durable, and a body with no metadata is an interrupted write.
+ */
+const PAYWALL_BODY_META_KEY_PREFIX = "api_paywall_body_meta:";
+const DEFAULT_MAX_BODY_ENTRIES = 500;
+class PaywallBodyCache {
+    constructor(storage = () => getPlatformAdapters().storage, maxEntries = DEFAULT_MAX_BODY_ENTRIES) {
+        this.storage = storage;
+        this.maxEntries = maxEntries;
+        /** Set under `campaign_cache_ttl == 0`: entries live here, in this process only. */
+        this.memory = null;
+        /** Metadata of every persisted entry, loaded once from the storage adapter. */
+        this.index = null;
+    }
+    get count() {
+        return this.memory ? this.memory.size : this.loadIndex().size;
+    }
+    /**
+     * Applies `campaign_cache_ttl` at the start of a resolution. `null` keeps everything, `n > 0`
+     * purges entries whose own age is `>= n` seconds, and `0` purges the persistent store and keeps
+     * this process's entries in memory only.
+     */
+    evaluateTtl(ttl, now = Date.now()) {
+        if (ttl === 0) {
+            if (this.memory)
+                return;
+            this.dropPersisted([...this.loadIndex().keys()]);
+            this.memory = new Map();
+            return;
+        }
+        // Leaving TTL 0 goes back to the persistent store; the process-local entries are dropped.
+        this.memory = null;
+        if (ttl === null)
+            return;
+        const expired = [...this.loadIndex().values()].filter((meta) => isExpired(meta, ttl, now));
+        this.dropPersisted(expired.map((meta) => meta.url));
+    }
+    /**
+     * The entry stored under this exact URL, or null when there is none, it is past `ttl`, or its
+     * body is missing (a half-written entry, which is deleted here).
+     */
+    validEntry(url, ttl, now = Date.now()) {
+        if (this.memory)
+            return this.memory.get(url) ?? null;
+        const meta = this.loadIndex().get(url);
+        if (!meta)
+            return null;
+        if (ttl !== null && ttl > 0 && isExpired(meta, ttl, now)) {
+            this.dropPersisted([url]);
+            return null;
+        }
+        const body = this.read(PAYWALL_BODY_KEY_PREFIX + url);
+        if (body === null) {
+            this.dropPersisted([url]);
+            return null;
+        }
+        return { meta, body };
+    }
+    /**
+     * The stored body for this exact URL, read straight from storage rather than through the index,
+     * with no TTL check. This is what rebuilds the aggregate `api_paywalls`, so it also sees an entry
+     * a host wrote after the index was loaded (the web test apps inject local test paywalls that way).
+     */
+    bodyFor(url) {
+        if (this.memory)
+            return this.memory.get(url)?.body ?? null;
+        return this.read(PAYWALL_BODY_KEY_PREFIX + url);
+    }
+    /** Stores a body under its exact URL. Returns false when the write did not land (quota, I/O). */
+    store(url, contentHash, body, now = Date.now()) {
+        const meta = { url, savedAt: now, ...(contentHash ? { contentHash } : {}) };
+        if (this.memory) {
+            this.memory.set(url, { meta, body });
+            return true;
+        }
+        const index = this.loadIndex();
+        const metaJson = JSON.stringify(meta);
+        // Body first, metadata last. Each write is verified by reading it back: the web adapter
+        // swallows a quota error rather than throwing, so a silent no-op is the common failure.
+        if (this.write(PAYWALL_BODY_KEY_PREFIX + url, body) &&
+            this.write(PAYWALL_BODY_META_KEY_PREFIX + url, metaJson)) {
+            index.set(url, meta);
+            return true;
+        }
+        logger.warn(`Paywall body cache: could not store ${url}; it will be fetched next time`);
+        this.dropPersisted([url]);
+        return false;
+    }
+    /** Stores a bundled body unless an entry already exists — a body the SDK fetched always wins. */
+    seedIfAbsent(url, contentHash, body, now = Date.now()) {
+        const exists = this.memory ? this.memory.has(url) : this.loadIndex().has(url);
+        return exists ? false : this.store(url, contentHash, body, now);
+    }
+    /** Deletes one entry — used for an undecodable body. Not eviction. */
+    remove(url) {
+        if (this.memory)
+            this.memory.delete(url);
+        else
+            this.dropPersisted([url]);
+    }
+    /**
+     * Eviction, run once per resolution after a complete `campaign_rules` fetch: delete every entry
+     * whose URL this resolution did not name, then cap the store at `maxEntries`, oldest first.
+     */
+    reconcile(currentUrls) {
+        const metas = this.memory
+            ? [...this.memory.values()].map((entry) => entry.meta)
+            : [...this.loadIndex().values()];
+        const unnamed = metas.filter((meta) => !currentUrls.has(meta.url)).map((meta) => meta.url);
+        const kept = metas.filter((meta) => currentUrls.has(meta.url)).sort((a, b) => a.savedAt - b.savedAt);
+        const overCap = kept.slice(0, Math.max(0, kept.length - this.maxEntries)).map((meta) => meta.url);
+        [...unnamed, ...overCap].forEach((url) => this.remove(url));
+    }
+    /** Empties the store — persisted and in-memory entries alike. Called by `Nami.reset()`. */
+    purgeAll() {
+        this.dropPersisted([...this.loadIndex().keys()]);
+        this.memory?.clear();
+    }
+    /** Builds the index from the metadata keys, clearing away half-written and unreadable entries. */
+    loadIndex() {
+        if (this.index)
+            return this.index;
+        this.index = new Map();
+        let keys;
+        try {
+            keys = this.storage().getAllKeys();
+        }
+        catch (error) {
+            logger.warn(`Paywall body cache: storage unavailable, caching nothing (${error})`);
+            return this.index;
+        }
+        const bodies = new Set(keys.filter((key) => key.startsWith(PAYWALL_BODY_KEY_PREFIX)).map((key) => key.slice(PAYWALL_BODY_KEY_PREFIX.length)));
+        const stale = [];
+        for (const key of keys) {
+            if (!key.startsWith(PAYWALL_BODY_META_KEY_PREFIX))
+                continue;
+            const url = key.slice(PAYWALL_BODY_META_KEY_PREFIX.length);
+            const meta = parseMeta(this.read(key));
+            if (meta?.url === url && bodies.has(url))
+                this.index.set(url, meta);
+            else
+                stale.push(url);
+            bodies.delete(url);
+        }
+        // Bodies whose metadata never landed: interrupted writes.
+        this.dropPersisted([...stale, ...bodies]);
+        return this.index;
+    }
+    dropPersisted(urls) {
+        for (const url of urls) {
+            this.index?.delete(url);
+            this.removeKey(PAYWALL_BODY_META_KEY_PREFIX + url);
+            this.removeKey(PAYWALL_BODY_KEY_PREFIX + url);
+        }
+    }
+    read(key) {
+        try {
+            return this.storage().getItem(key);
+        }
+        catch {
+            return null;
+        }
+    }
+    write(key, value) {
+        try {
+            this.storage().setItem(key, value);
+        }
+        catch {
+            return false;
+        }
+        return this.read(key) === value;
+    }
+    removeKey(key) {
+        try {
+            this.storage().removeItem(key);
+        }
+        catch {
+            // Nothing more to do: an entry that cannot be deleted is re-validated on the next read.
+        }
+    }
+}
+function isExpired(meta, ttlSeconds, now) {
+    return (now - meta.savedAt) / 1000 >= ttlSeconds;
+}
+function parseMeta(raw) {
+    if (raw === null)
+        return null;
+    try {
+        const meta = JSON.parse(raw);
+        return typeof meta?.url === "string" && typeof meta?.savedAt === "number" ? meta : null;
+    }
+    catch {
+        return null;
+    }
+}
+const paywallBodyCache = new PaywallBodyCache();
+
 class StorageService {
     constructor() {
         this.memoryStore = {};
@@ -3129,6 +3347,20 @@ class StorageService {
         }
         this.setItem(key, paywalls);
     }
+    /**
+     * Writes the aggregate `api_paywalls` as the list of URLs a per-URL resolution produced, rather
+     * than a second copy of their bodies (NAM-4357): the bodies already live in the per-URL body
+     * cache, and `getPaywalls(API_PAYWALLS)` rebuilds the paywall objects from it. The legacy bulk
+     * path still writes whole objects through `setPaywalls`.
+     */
+    setApiPaywallsFromBodyCache(urls) {
+        const index = { bodyCacheUrls: urls };
+        if (this.getCampaignCacheTtl() === 0) {
+            this.memoryStore[exports.API_PAYWALLS] = JSON.stringify(index);
+            return;
+        }
+        this.setItem(exports.API_PAYWALLS, index);
+    }
     getPaywalls(key) {
         if (key === exports.INITIAL_PAYWALLS) {
             return this.memoryStore[exports.INITIAL_PAYWALLS]
@@ -3137,8 +3369,10 @@ class StorageService {
         }
         if (key === exports.API_PAYWALLS) {
             const memoryValue = this.memoryStore[exports.API_PAYWALLS];
-            if (memoryValue != null)
-                return JSON.parse(memoryValue);
+            if (memoryValue != null) {
+                const parsed = JSON.parse(memoryValue);
+                return isBodyCacheAggregate(parsed) ? paywallsFromBodyCache(parsed.bodyCacheUrls) : parsed;
+            }
             let stored = this.getItem(exports.API_PAYWALLS);
             if (stored === null)
                 return null;
@@ -3150,6 +3384,8 @@ class StorageService {
                     return stored;
                 }
             }
+            if (isBodyCacheAggregate(stored))
+                return paywallsFromBodyCache(stored.bodyCacheUrls);
             return this.isLegacyTimestampedCache(stored) ? stored.data : stored;
         }
         return this.getItem(key);
@@ -3318,7 +3554,18 @@ class StorageService {
         this.resetItem(exports.API_CAMPAIGN_RULES);
         this.resetItem(exports.API_CAMPAIGN_SESSION_TIMESTAMP);
     }
+    /**
+     * The effective `campaign_cache_ttl`: a `campaignCacheTTL=<n>` namiCommand first, then the API
+     * config, then the initial config. Lives here rather than in `utils/config` because this service
+     * needs it to decide where the aggregate caches go, and `utils/config` already imports this one.
+     */
     getCampaignCacheTtl() {
+        const override = this.getNamiConfig()?.namiCommands
+            ?.filter((cmd) => cmd.startsWith(exports.CAMPAIGN_CACHE_TTL_PREFIX))
+            .map((cmd) => cmd.slice(exports.CAMPAIGN_CACHE_TTL_PREFIX.length))
+            .find((value) => /^\d+$/.test(value));
+        if (override !== undefined)
+            return parseInt(override, 10);
         const config = this.getAppConfig(exports.API_CONFIG)
             || this.getAppConfig(exports.INITIAL_APP_CONFIG);
         return config?.campaign_cache_ttl ?? null;
@@ -3410,6 +3657,28 @@ class StorageService {
         this.memoryStore = {};
     }
 }
+function isBodyCacheAggregate(value) {
+    return typeof value === "object" && value !== null && Array.isArray(value.bodyCacheUrls);
+}
+/**
+ * The paywalls a per-URL resolution produced, decoded from the body cache. A URL whose entry has
+ * since gone (evicted, purged, or a write that never landed) is simply absent.
+ */
+function paywallsFromBodyCache(urls) {
+    const paywalls = [];
+    for (const url of urls) {
+        const body = paywallBodyCache.bodyFor(url);
+        if (body === null)
+            continue;
+        try {
+            paywalls.push(JSON.parse(body));
+        }
+        catch {
+            paywallBodyCache.remove(url);
+        }
+    }
+    return paywalls;
+}
 const storageService = new StorageService();
 
 class RetryLimitExceededError extends Error {
@@ -6787,11 +7056,8 @@ const hasCapability = (capability) => {
         || storageService.getAppConfig(exports.INITIAL_APP_CONFIG);
     return appConfig?.capabilities?.includes(capability) ?? false;
 };
-const getCampaignCacheTtl = () => {
-    const config = storageService.getAppConfig(exports.API_CONFIG)
-        || storageService.getAppConfig(exports.INITIAL_APP_CONFIG);
-    return config?.campaign_cache_ttl ?? null;
-};
+/** The effective `campaign_cache_ttl`, `campaignCacheTTL=<n>` namiCommand first. */
+const getCampaignCacheTtl = () => storageService.getCampaignCacheTtl();
 /**
  * The effective global journey settings from the current config, coalescing a missing
  * `journey_settings` object — or any missing field — to {@link DEFAULT_JOURNEY_SETTINGS}.
@@ -57498,22 +57764,23 @@ class CampaignRuleRepository {
     static hasPaywallUrls(campaigns) {
         return campaigns.some((c) => c.paywall_url || c.page_urls || c.flow?.page_urls);
     }
+    /**
+     * The campaign rules for this form factor, unvalidated, plus whether they came from the network.
+     * `fromNetwork` is false when the stored rules stood in for a failed fetch (or updates are
+     * disabled): the per-URL body cache must then neither resolve nor evict (NAM-4357).
+     */
     async fetchCampaignRulesRaw() {
-        const authDevice = storageService.getDevice();
         if (this.disableCampaignUpdates) {
             logger.info("Campaign updates disabled by configuration. Skipping fetch.");
-            return [];
+            return { campaigns: [], fromNetwork: false };
         }
-        let campaignRules;
-        if (!authDevice?.id) {
-            campaignRules = await this.getAnonymousCampaigns();
-        }
-        else {
-            campaignRules = await this.getCampaigns(authDevice.id);
-        }
-        campaignRules = campaignRules?.filter((cRule) => (cRule.paywall && cRule.form_factors.some((f) => f.form_factor === this.currentFormFactor)) ||
+        const authDevice = storageService.getDevice();
+        const fetched = authDevice?.id
+            ? await this.fetchCampaigns(authDevice.id)
+            : await this.fetchAnonymousCampaigns();
+        const campaigns = fetched.campaigns?.filter((cRule) => (cRule.paywall && cRule.form_factors.some((f) => f.form_factor === this.currentFormFactor)) ||
             (cRule.flow && cRule.form_factors?.some((f) => f.form_factor === this.currentFormFactor)));
-        return campaignRules;
+        return { campaigns, fromNetwork: fetched.fromNetwork };
     }
     finalizeCampaignRules(campaignRules, paywalls) {
         // NAM-2457: a server flow rule is kept only when BOTH assets are satisfied —
@@ -57549,10 +57816,19 @@ class CampaignRuleRepository {
         listeners.forEach((handler) => handler(campaigns));
     }
     async getAnonymousCampaigns(sdkVersion = exports.NAMI_SDK_VERSION) {
+        return (await this.fetchAnonymousCampaigns(sdkVersion)).campaigns;
+    }
+    async getCampaigns(deviceId) {
+        return (await this.fetchCampaigns(deviceId)).campaigns;
+    }
+    async fetchAnonymousCampaigns(sdkVersion = exports.NAMI_SDK_VERSION) {
         const path = `campaign_rules/?sdk_version=${sdkVersion}`;
         try {
             const resp = await NamiAPI.instance.fetchAPI(path);
-            return mapAnonymousCampaigns(resp.results ?? [], this.splitPosition, this.currentFormFactor);
+            return {
+                campaigns: mapAnonymousCampaigns(resp.results ?? [], this.splitPosition, this.currentFormFactor),
+                fromNetwork: true,
+            };
         }
         catch (error) {
             const data = this.fallbackData();
@@ -57560,23 +57836,23 @@ class CampaignRuleRepository {
                 logger.error(handleErrors(error.status, path));
                 throw error;
             }
-            return data.results;
+            return { campaigns: data.results, fromNetwork: false };
         }
     }
-    async getCampaigns(deviceId) {
+    async fetchCampaigns(deviceId) {
         const path = `device/${deviceId}/campaign_rules/`;
-        let data;
         try {
-            data = await NamiAPI.instance.fetchAPI(path);
+            const data = await NamiAPI.instance.fetchAPI(path);
+            return { campaigns: data?.results || [], fromNetwork: true };
         }
         catch (error) {
-            data = this.fallbackData();
+            const data = this.fallbackData();
             if (!data) {
                 logger.error(handleErrors(error.status, path));
                 throw error;
             }
+            return { campaigns: data.results || [], fromNetwork: false };
         }
-        return data?.results || [];
     }
     fallbackData() {
         const storedData = storageService.getCampaignRules(exports.API_CAMPAIGN_RULES)
@@ -57859,6 +58135,15 @@ const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
  * RetryExhaustedError when all attempts and/or the budget are spent.
  */
 async function fetchWithCdnRetry(url, opts = {}) {
+    const { data, retryCount } = await fetchTextWithCdnRetry(url, opts);
+    return { data: JSON.parse(data), retryCount };
+}
+/**
+ * {@link fetchWithCdnRetry}'s retry loop, returning the raw 2xx body text instead of parsed JSON.
+ * The per-URL paywall body cache stores those exact bytes, so a cached body is decoded by the
+ * same `JSON.parse` a fetched one is (NAM-4357).
+ */
+async function fetchTextWithCdnRetry(url, opts = {}) {
     const maxAttempts = opts.maxAttempts ?? DEFAULTS.maxAttempts;
     const baseDelayMs = opts.baseDelayMs ?? DEFAULTS.baseDelayMs;
     const maxDelayMs = opts.maxDelayMs ?? DEFAULTS.maxDelayMs;
@@ -57908,8 +58193,7 @@ async function fetchWithCdnRetry(url, opts = {}) {
                 const responseBody = await response.clone().text();
                 logger.debug(`[HTTP] Response ${response.status}: ${responseBody}`);
             }
-            const data = (await response.json());
-            return { data, retryCount: attempt };
+            return { data: await response.text(), retryCount: attempt };
         }
         catch (err) {
             if (err instanceof NonRetryableHttpError)
@@ -57930,7 +58214,43 @@ async function fetchWithCdnRetry(url, opts = {}) {
     throw new RetryExhaustedError(url, attempt, lastStatus);
 }
 
+/**
+ * Reads the parts of a `campaign_rules` paywall URL the per-URL body cache needs (NAM-4357).
+ *
+ * Both helpers scan the string rather than build a `URL`: the cache is keyed on the exact bytes
+ * the server sent, so nothing here may normalise, re-encode or reject a URL — a malformed one is
+ * simply un-hashed.
+ */
+/**
+ * The `content_hash` query value, or undefined when it is missing or empty. When the item appears
+ * more than once the first value wins. The value is never parsed or validated: it is a
+ * cache-validity token, not a content selector.
+ */
+function contentHashOf(url) {
+    const query = url.split("#")[0].split("?")[1];
+    if (!query)
+        return undefined;
+    for (const item of query.split("&")) {
+        const eq = item.indexOf("=");
+        const name = eq === -1 ? item : item.slice(0, eq);
+        if (name !== "content_hash")
+            continue;
+        const value = eq === -1 ? "" : item.slice(eq + 1);
+        return value || undefined;
+    }
+    return undefined;
+}
+/** The path segment after `/paywall/` — the paywall id the URL names — or undefined. */
+function paywallIdOf(url) {
+    const path = url.split(/[?#]/)[0];
+    const match = /\/paywall\/([^/]+)/.exec(path);
+    return match ? match[1] : undefined;
+}
+
 class PaywallRepository {
+    constructor(bodyCache = paywallBodyCache) {
+        this.bodyCache = bodyCache;
+    }
     async fetchPaywalls() {
         const authDevice = storageService.getDevice();
         let paywalls;
@@ -57979,34 +58299,131 @@ class PaywallRepository {
         }
         return data?.results || [];
     }
-    async fetchPaywallByUrl(url) {
-        return fetchWithCdnRetry(url);
-    }
-    async fetchPaywallsByUrls(urls) {
+    /**
+     * Resolves the URL set named by `campaign_rules` into paywall objects — the decision table of
+     * `api-resilience-and-caching.md` § 2.2, run identically at startup and on `refresh()`:
+     *
+     * | URL       | entry for the exact URL within TTL | action                        | provenance               |
+     * |-----------|------------------------------------|-------------------------------|--------------------------|
+     * | hashed    | yes                                | serve it, no request          | `cacheHit`               |
+     * | hashed    | no                                 | fetch; store the 2xx body     | `fetched`                |
+     * | un-hashed | not consulted                      | fetch; store the 2xx body     | `fetched`                |
+     * | either    | fetch failed, entry within TTL     | serve it, keep it             | `cacheAfterFetchFailure` |
+     * | either    | fetch failed, no entry             | no body                       | counts `failed`          |
+     *
+     * Writes the aggregate `api_paywalls` — as the URLs of every body this resolution produced, since
+     * the bodies themselves are already in the body cache — unless it produced none, so an outage
+     * cannot overwrite a good aggregate with an empty one. Eviction is the caller's: it runs only
+     * after a complete `campaign_rules` fetch.
+     */
+    async resolvePaywallsByUrls(urls) {
         const uniqueUrls = [...new Set(urls)];
-        const results = await Promise.allSettled(uniqueUrls.map((url) => this.fetchPaywallByUrl(url)));
-        const paywalls = [];
-        let retryCount = 0;
-        for (const result of results) {
-            if (result.status === "fulfilled") {
-                paywalls.push(result.value.data);
-                retryCount += result.value.retryCount;
-            }
-            else {
-                // Note: an exhausted-failure path contributed retries we can't see
-                // from the rejected promise, so retryCount under-reports failures.
-                // Acceptable for the telemetry signal; revisit if full accounting matters.
-                logger.error(`Failed to fetch individual paywall: ${result.reason}`);
+        const ttl = getCampaignCacheTtl();
+        this.bodyCache.evaluateTtl(ttl);
+        const resolutions = await Promise.all(uniqueUrls.map((url) => this.resolvePaywall(url, ttl)));
+        const outcome = {
+            paywalls: [],
+            urls: uniqueUrls.length,
+            hashed: uniqueUrls.filter((url) => contentHashOf(url) !== undefined).length,
+            cacheHits: 0,
+            fetched: 0,
+            cacheAfterFetchFailure: 0,
+            failed: 0,
+            retryCount: 0,
+        };
+        const resolvedUrls = new Map();
+        resolutions.forEach((resolution, i) => {
+            outcome.retryCount += resolution.retryCount;
+            if (!resolution.paywall) {
+                outcome.failed += 1;
+                return;
             }
+            resolvedUrls.set(resolution.paywall, uniqueUrls[i]);
+            if (resolution.paywall.fetchSource === "cacheHit")
+                outcome.cacheHits += 1;
+            else if (resolution.paywall.fetchSource === "cacheAfterFetchFailure")
+                outcome.cacheAfterFetchFailure += 1;
+            else
+                outcome.fetched += 1;
+        });
+        outcome.paywalls = this.validatePaywalls([...resolvedUrls.keys()]);
+        if (outcome.paywalls.length > 0) {
+            storageService.setApiPaywallsFromBodyCache(outcome.paywalls.map((paywall) => resolvedUrls.get(paywall)));
         }
-        if (paywalls.length > 0) {
-            const valid = this.validatePaywalls(paywalls);
-            if (valid.length > 0) {
-                storageService.setPaywalls(exports.API_PAYWALLS, valid);
+        return outcome;
+    }
+    /**
+     * Seeds the body cache from the initial-config bundle (§ 2.2 "Seeding"): every **hashed** bundled
+     * URL whose paywall id matches a bundled body is stored under that exact URL unless an entry
+     * already exists. A hash in a bundled URL was minted against the bundled body, so the pair is
+     * exact. Runs at configure, before the first resolution.
+     */
+    seedFromInitialConfig(campaignRules, paywalls) {
+        const bundled = new Map(paywalls.map((paywall) => [paywall.id, paywall]));
+        this.bodyCache.evaluateTtl(getCampaignCacheTtl());
+        let candidates = 0;
+        let seeded = 0;
+        for (const url of new Set(bundledPaywallUrls(campaignRules))) {
+            const contentHash = contentHashOf(url);
+            const id = paywallIdOf(url);
+            const paywall = id ? bundled.get(id) : undefined;
+            if (!contentHash || !paywall)
+                continue;
+            candidates += 1;
+            if (this.bodyCache.seedIfAbsent(url, contentHash, JSON.stringify(paywall)))
+                seeded += 1;
+        }
+        logger.info(`Paywall body cache seeded from initial config: seeded=${seeded}, candidates=${candidates}`);
+    }
+    /** One row of the decision table. Never throws. */
+    async resolvePaywall(url, ttl) {
+        const contentHash = contentHashOf(url);
+        if (contentHash) {
+            const hit = this.decodeCached(url, ttl);
+            if (hit)
+                return { paywall: withProvenance(hit, "cacheHit", contentHash), retryCount: 0 };
+        }
+        let retryCount = 0;
+        try {
+            const response = await this.fetchPaywallText(url);
+            retryCount = response.retryCount;
+            const paywall = decodePaywall(response.data);
+            if (paywall) {
+                this.bodyCache.store(url, contentHash, response.data);
+                return { paywall: withProvenance(paywall, "fetched", contentHash), retryCount };
             }
-            return { paywalls: valid, retryCount };
+            logger.error(`Paywall body from ${url} is not a decodable paywall`);
+        }
+        catch (error) {
+            // Note: an exhausted-failure path contributed retries we can't see from the thrown error,
+            // so retry_count under-reports failures. Acceptable for the telemetry signal.
+            logger.error(`Failed to fetch individual paywall: ${error}`);
+        }
+        const fallback = this.decodeCached(url, ttl);
+        if (fallback) {
+            logger.warn(`Serving the cached body for ${url} after fetch failure (within campaign_cache_ttl)`);
+            return { paywall: withProvenance(fallback, "cacheAfterFetchFailure", contentHash), retryCount };
         }
-        return { paywalls, retryCount };
+        return { retryCount };
+    }
+    /** The stored body for this exact URL, decoded; an undecodable one is deleted (not eviction). */
+    decodeCached(url, ttl) {
+        const entry = this.bodyCache.validEntry(url, ttl);
+        if (!entry)
+            return undefined;
+        const paywall = decodePaywall(entry.body);
+        if (!paywall) {
+            logger.warn(`Deleting an undecodable cached paywall body for ${url}`);
+            this.bodyCache.remove(url);
+        }
+        return paywall;
+    }
+    fetchPaywallText(url) {
+        if (storageService.getNamiConfig()?.namiCommands?.includes(exports.SIMULATE_PAYWALL_FETCH_FAILURE)) {
+            logger.warn(`${exports.SIMULATE_PAYWALL_FETCH_FAILURE}: failing the fetch for ${url} before the network`);
+            return Promise.reject(new RetryExhaustedError(url, 0));
+        }
+        return fetchTextWithCdnRetry(url);
     }
     validatePaywalls(paywalls) {
         return paywalls.filter((paywall) => {
@@ -58031,29 +58448,154 @@ class PaywallRepository {
     }
 }
 PaywallRepository.instance = new PaywallRepository();
+function decodePaywall(text) {
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function withProvenance(paywall, fetchSource, contentHash) {
+    return { ...paywall, fetchSource, ...(contentHash ? { contentHash } : {}) };
+}
+/** Every paywall URL a bundled (anonymous-format) rule names, across all of its segments. */
+function bundledPaywallUrls(campaignRules) {
+    const urls = [];
+    for (const rule of campaignRules) {
+        for (const segment of rule.segments ?? []) {
+            if (segment.paywall_url)
+                urls.push(segment.paywall_url);
+            if (segment.page_urls)
+                urls.push(...Object.values(segment.page_urls));
+            if (segment.flow?.page_urls)
+                urls.push(...Object.values(segment.flow.page_urls));
+        }
+    }
+    return urls;
+}
 
 class ConfigRepository {
+    /**
+     * One `GET config/` attempt. Persists the config on success and throws on any failure —
+     * a non-2xx or a transport error alike. `withRetry`'s own retries are turned off, so the
+     * attempt count belongs to {@link fetchConfigForStartup} alone.
+     */
     async fetchConfig() {
-        let data;
-        try {
-            data = await NamiAPI.instance.fetchAPI("config/");
-            ;
-        }
-        catch (error) {
-            data = storageService.getAppConfig(exports.API_CONFIG)
-                || storageService.getAppConfig(exports.INITIAL_APP_CONFIG);
-            if (!data) {
-                logger.error(handleErrors(error.status, "config/"));
-                throw error;
-            }
+        // Thrown from *inside* the attempt on purpose, like Apple's and Android's: the ladder then
+        // treats it exactly as a real 500, which is the whole point of the mock.
+        if (storageService.getNamiConfig()?.namiCommands?.includes(exports.SIMULATE_CONFIG_FETCH_FAILURE)) {
+            throw new RetryLimitExceededError(exports.STATUS_INTERNAL_SERVER_ERROR, exports.SIMULATE_CONFIG_FETCH_FAILURE);
         }
-        if (data) {
+        const platformId = storageService.getNamiConfig()?.appPlatformID;
+        const data = await NamiAPI.instance.fetchAPI("config/", exports.CONFIG_API_TIMEOUT_LIMIT, 0);
+        // A late answer (the startup await gave up on it) must not overwrite another platform's
+        // config after a reset or a platform-switching reconfigure.
+        if (storageService.getNamiConfig()?.appPlatformID === platformId) {
             storageService.setAppConfig(exports.API_CONFIG, data);
         }
+        else {
+            logger.debug("Discarding an app config response for a platform that is no longer configured");
+        }
         return data;
     }
+    /**
+     * The startup platform-config step, converged on Apple's `NamiPlatformConfigService.fetch` and
+     * Android's `fetchAppConfigOnce` (NAM-4470, NAM-4589):
+     *
+     * | case | outcome |
+     * |---|---|
+     * | an initial config was supplied | NOT awaited: one attempt runs in the background and stores the config when it lands; usable |
+     * | no initial config, success, capabilities include `sdk` | usable |
+     * | no initial config, success, capabilities lack `sdk` | not usable |
+     * | no initial config, failure | {@link CONFIG_MAX_ATTEMPTS} attempts of up to {@link CONFIG_API_TIMEOUT_LIMIT} each, then usable only if a config is cached (and grants `sdk`) |
+     *
+     * The two fallbacks are consulted at two different points, deliberately. An initial config
+     * decides the case *before* any request: startup does not wait on the network at all, since the
+     * initial config is what makes the SDK ready without it (Apple: "Initial config is available.
+     * Skipping retry."). The config cached by a previous launch is consulted only *after* the
+     * retries run out. A stored `INITIAL_APP_CONFIG` is not that cache.
+     *
+     * One check does apply with an initial config, because it costs no wait: a cached config that
+     * withholds `sdk` still stops startup, as Apple's cache load re-applies `updateSdkFlags`.
+     * Without it a kill switch could never reach an app that ships an initial config — the
+     * background fetch lands after startup has already run, so it takes effect from the next launch.
+     *
+     * A `404` is treated as any other 4xx, matching Apple's effective behaviour (its dedicated 404
+     * branch is unreachable, NAM-4471) and Android's.
+     *
+     * @param hasInitialConfig whether the host passed an `initialConfig` that decoded to content.
+     */
+    async fetchConfigForStartup(hasInitialConfig) {
+        if (hasInitialConfig)
+            return this.startupOnInitialConfig();
+        const maxAttempts = exports.CONFIG_MAX_ATTEMPTS;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            if (attempt > 1) {
+                logger.debug(`Retrying app config fetch (attempt ${attempt} of ${maxAttempts})`);
+            }
+            try {
+                return outcomeOf(await this.fetchConfig());
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        const cached = storageService.getAppConfig(exports.API_CONFIG);
+        if (cached) {
+            // A cached kill switch still holds: Apple re-applies `updateSdkFlags` when it loads the
+            // cached config, so one that withheld `sdk` keeps the SDK disabled through an outage.
+            if (!grantsSdk(cached)) {
+                return { usable: false, reason: "the cached app config does not grant the 'sdk' capability" };
+            }
+            logger.info(`App config fetch failed after ${maxAttempts} attempts - continuing on the cached config`);
+            return { usable: true };
+        }
+        return {
+            usable: false,
+            reason: `app config fetch failed after ${maxAttempts} attempts (${describeFailure(lastError)}) ` +
+                "and no initial or cached config is available",
+        };
+    }
+    /**
+     * The initial-config case: nothing is awaited. The cached kill switch is a storage read; the
+     * config request is left running and persists its answer (`fetchConfig`) when it lands.
+     */
+    startupOnInitialConfig() {
+        // Read before the request can land, so this launch is judged on what the last one stored.
+        const cached = storageService.getAppConfig(exports.API_CONFIG);
+        // Issued even when the cache holds a kill switch: that is how a LIFTED kill switch reaches
+        // the next launch.
+        this.fetchConfig().then((config) => {
+            if (!grantsSdk(config)) {
+                logger.warn("App config does not grant the 'sdk' capability - it takes effect from the next launch");
+            }
+        }, (error) => {
+            logger.info(`App config fetch failed (${describeFailure(error)}). Initial config is available. Skipping retry.`);
+        });
+        if (cached && !grantsSdk(cached)) {
+            return { usable: false, reason: "the cached app config does not grant the 'sdk' capability" };
+        }
+        return { usable: true };
+    }
 }
 ConfigRepository.instance = new ConfigRepository();
+function outcomeOf(config) {
+    return grantsSdk(config)
+        ? { usable: true }
+        : { usable: false, reason: "app config does not grant the 'sdk' capability" };
+}
+function grantsSdk(config) {
+    return config.capabilities?.includes(exports.Capabilities.SDK) ?? false;
+}
+function describeFailure(error) {
+    const status = error?.status;
+    if (typeof status === "number")
+        return `HTTP ${status}`;
+    return error instanceof Error ? error.message : String(error);
+}
 
 // Global reference to avoid circular imports
 let namiRefsInstance = null;
@@ -61597,6 +62139,15 @@ class NamiRefs {
         this.inMemoryAnonymousMode = false;
         // Captured before device registration; true only on genuine fresh installs
         this.isFirstSession = false;
+        // Set when the platform-config step leaves no usable config (see isStartupDisabled)
+        this.startupDisabled = false;
+        // Whether this configure() supplied an initial config (the config ladder's early exit)
+        this.hasInitialConfig = false;
+        // Resume bookkeeping: the configuration startup last ran with, when it (or a resume) last
+        // ran, and whether one is running now.
+        this.lastConfig = null;
+        this.lastStartupRunAt = 0;
+        this.startupInFlight = false;
         // Register this instance to avoid circular dependency issues
         setNamiRefsInstance(this);
     }
@@ -61614,13 +62165,101 @@ class NamiRefs {
     getIsFirstSession() {
         return this.isFirstSession;
     }
+    /**
+     * True when the platform-config step found no usable config and startup stopped after it —
+     * the equivalent of Apple's `sdkEnabled = false` and Android's `NamiRefs.startupDisabled`.
+     * Like both, it gates only the startup sequence, nothing else.
+     */
+    isStartupDisabled() {
+        return this.startupDisabled;
+    }
     async init(config) {
         this.isFirstSession = storageService.getDevice() === null && !storageService.getAnonymousMode();
+        // Cleared per configure so a transient failure cannot disable a later run.
+        this.startupDisabled = false;
+        // `Nami.configure` has already normalised a missing or undecodable initialConfig to `{}`,
+        // so "has content" is Apple's `initialConfig != nil`.
+        this.hasInitialConfig = Object.keys(config.initialConfig ?? {}).length > 0;
         this.setInitialValues(config);
-        ConfigRepository.instance.fetchConfig();
+        this.lastConfig = config;
+        this.lastStartupRunAt = Date.now();
+        this.startupInFlight = true;
+        try {
+            if (!(await this.fetchPlatformConfig()))
+                return;
+            await this.runStartupAfterConfig(config);
+        }
+        finally {
+            this.startupInFlight = false;
+        }
+    }
+    /**
+     * The app returned to the foreground. Re-reads the platform config, as Apple's `.appResume`
+     * and Android's `onAppComesFromBackground` do, so a config change — the `sdk` kill switch
+     * included — reaches a long-lived tab or app without a cold start.
+     *
+     * - Skipped within {@link RESUME_THROTTLE_MS} of the last launch/resume, and while one is
+     *   still running.
+     * - When the launch had **stopped** for want of a config and one is now usable, the rest of
+     *   startup runs — the steps an Apple resume re-runs because the launch never executed them.
+     * - Otherwise this is a config refresh only. Apple and Android also re-run device, campaigns,
+     *   profile, products and the session start on resume; core does not yet, and has no
+     *   session end on background for a second session start to pair with (NAM-4623).
+     */
+    async resume() {
+        if (!this.lastConfig || this.startupInFlight)
+            return;
+        if (Date.now() - this.lastStartupRunAt < exports.RESUME_THROTTLE_MS) {
+            logger.debug("Resuming too quickly to call the service.");
+            return;
+        }
+        const config = this.lastConfig;
+        const wasStopped = this.startupDisabled;
+        this.lastStartupRunAt = Date.now();
+        this.startupInFlight = true;
+        this.startupDisabled = false;
+        try {
+            if (!(await this.fetchPlatformConfig()) || !wasStopped)
+                return;
+            logger.info("Usable app config on resume - completing the startup that stopped at launch");
+            await this.runStartupAfterConfig(config);
+        }
+        catch (error) {
+            logger.warn(`Resume refresh failed: ${error}`);
+        }
+        finally {
+            this.startupInFlight = false;
+        }
+    }
+    /** Everything startup runs once the platform-config step has found a usable config. */
+    async runStartupAfterConfig(config) {
         await this.initAndFetchRequiredData(config);
         SessionService.instance.startSession();
     }
+    /** Forgets the configuration a resume would run against; called by `Nami.reset()`. */
+    clearResumeState() {
+        this.lastConfig = null;
+        this.lastStartupRunAt = 0;
+        this.startupDisabled = false;
+    }
+    /**
+     * The platform-config startup step, ahead of device registration — the position it holds on
+     * Apple (`.fetchPlatformConfig`) and Android (`fetchAppConfigOnce`) (NAM-4464, NAM-4589).
+     * Without an initial config it is awaited, so everything downstream — `campaign_cache_ttl`
+     * included — is evaluated against the config it leaves in storage. With one it resolves at
+     * once and the request finishes in the background (see `fetchConfigForStartup`).
+     *
+     * @returns false when there is no usable config, in which case startup must stop.
+     */
+    async fetchPlatformConfig() {
+        const outcome = await ConfigRepository.instance.fetchConfigForStartup(this.hasInitialConfig);
+        if (!outcome.usable) {
+            this.startupDisabled = true;
+            logger.error(`Nami startup stopped: ${outcome.reason}`);
+            return false;
+        }
+        return true;
+    }
     setInitialValues(config) {
         const baseConfig = { ...config };
         delete baseConfig.initialConfig;
@@ -61636,7 +62275,10 @@ class NamiRefs {
             }
         }
         if (initconfig?.paywalls) {
-            storageService.setPaywalls(exports.INITIAL_PAYWALLS, initconfig.paywalls);
+            storageService.setPaywalls(exports.INITIAL_PAYWALLS, initconfig.paywalls.map((paywall) => ({ ...paywall, fetchSource: "initialConfig" })));
+            if (initconfig.campaign_rules?.length) {
+                PaywallRepository.instance.seedFromInitialConfig(initconfig.campaign_rules, initconfig.paywalls);
+            }
         }
         if (initconfig?.products) {
             storageService.setProducts(exports.INITIAL_PRODUCTS, initconfig.products);
@@ -61703,7 +62345,7 @@ class NamiRefs {
         const paywallRepo = PaywallRepository.instance;
         const startTime = Date.now();
         const campaignRulesStartTime = Date.now();
-        const rawCampaigns = await campaignRepo.fetchCampaignRulesRaw();
+        const { campaigns: rawCampaigns, fromNetwork } = await campaignRepo.fetchCampaignRulesRaw();
         const campaignRulesDuration = Date.now() - campaignRulesStartTime;
         // Hydrate flow objects: fetch flow JSON from flow.url for campaigns that
         // use the URL-based format (4.0.0+ since NAM-3493) instead of inline flow.object
@@ -61724,24 +62366,35 @@ class NamiRefs {
         const useIndividual = !campaignRepo.useLegacyPaywallFetch &&
             CampaignRuleRepository.hasPaywallUrls(rawCampaigns);
         let paywalls;
-        let retryCount = 0;
+        let outcome = null;
         const paywallsStartTime = Date.now();
-        if (useIndividual) {
+        if (useIndividual && !fromNetwork) {
+            // campaign_rules came from the stored copy, so this is not a complete page set: no
+            // resolution and no eviction (api-resilience-and-caching.md § 2.2). The aggregate serves.
+            logger.info("Paywall resolution skipped: campaign_rules were served from the stored copy");
+            paywalls = getApiPaywalls();
+        }
+        else if (useIndividual) {
             const urls = CampaignRuleRepository.extractPaywallUrls(rawCampaigns);
-            const result = await paywallRepo.fetchPaywallsByUrls(urls);
-            paywalls = result.paywalls;
-            retryCount = result.retryCount;
+            outcome = await paywallRepo.resolvePaywallsByUrls(urls);
+            paywalls = outcome.paywalls;
+            paywallBodyCache.reconcile(new Set(urls));
         }
         else {
             paywalls = await paywallRepo.fetchPaywalls();
         }
         const paywallsDuration = Date.now() - paywallsStartTime;
         const totalDuration = Date.now() - startTime;
-        if (Nami.instance.maxLogging) {
-            logger.info(`Paywall fetch telemetry: strategy=${useIndividual ? "individual" : "bulk"}, ` +
-                `count=${paywalls.length}, total=${totalDuration}ms, ` +
+        if (!useIndividual || outcome) {
+            // The line every SDK emits once per resolution; the paywall-cache e2e suites parse it.
+            const cacheFields = outcome
+                ? `, urls=${outcome.urls}, hashed=${outcome.hashed}, cache_hits=${outcome.cacheHits}, ` +
+                    `fetched=${outcome.fetched}, cache_after_fetch_failure=${outcome.cacheAfterFetchFailure}, failed=${outcome.failed}`
+                : "";
+            logger.debug(`Paywall fetch telemetry: strategy=${useIndividual ? "individual" : "bulk"}, ` +
+                `count=${paywalls.length}${cacheFields}, total=${totalDuration}ms, ` +
                 `campaigns=${campaignRulesDuration}ms, paywalls=${paywallsDuration}ms` +
-                `${useIndividual ? `, retry_count=${retryCount}` : ""}`);
+                `${outcome ? `, retry_count=${outcome.retryCount}` : ""}`);
         }
         return campaignRepo.finalizeCampaignRules(rawCampaigns, paywalls);
     }
@@ -61881,7 +62534,7 @@ class LastLaunchStore {
     }
 }
 
-var _Nami_isInitialized;
+var _Nami_isInitialized, _Nami_removeForegroundListener;
 // NamiFlowManager is intentionally NOT imported at top level — it
 // transitively imports back to this module (`Nami` for logging), and
 // pulling it in here causes a load-order cycle that breaks tests
@@ -61889,6 +62542,7 @@ var _Nami_isInitialized;
 class Nami {
     constructor() {
         _Nami_isInitialized.set(this, false);
+        _Nami_removeForegroundListener.set(this, null);
         this.maxLogging = false;
     }
     get isInitialized() {
@@ -61912,9 +62566,15 @@ class Nami {
      * integrating app, consistent with the Apple and Android SDKs.
      */
     static async reset() {
+        var _a;
         storageService.clearAll();
+        // The per-URL paywall body cache keeps its own prefixed keys and an in-memory index (NAM-4357).
+        paywallBodyCache.purgeAll();
         clearInMemoryAnonymousMode();
         __classPrivateFieldSet(Nami.instance, _Nami_isInitialized, false, "f");
+        __classPrivateFieldGet((_a = Nami.instance), _Nami_removeForegroundListener, "f")?.call(_a);
+        __classPrivateFieldSet(Nami.instance, _Nami_removeForegroundListener, null, "f");
+        NamiRefs.instance.clearResumeState();
         // In-memory singleton state that previously survived reset and
         // bled into the next configure() cycle.
         NamiProfileManager$1.instance.setExternalId(undefined);
@@ -61977,6 +62637,18 @@ class Nami {
         }
         config.initialConfig = {};
     }
+    /**
+     * Subscribes the resume config refresh to the host's foreground signal, once per process —
+     * a reconfigure must not stack a second listener (the Android defect NAM-4541 fixed).
+     * Registered before startup runs; `resume()` itself skips while startup is in flight.
+     */
+    listenForAppForeground() {
+        if (__classPrivateFieldGet(this, _Nami_removeForegroundListener, "f"))
+            return;
+        __classPrivateFieldSet(this, _Nami_removeForegroundListener, getPlatformAdapters().device.onAppForeground?.(() => {
+            void NamiRefs.instance.resume();
+        }) ?? null, "f");
+    }
     async initializeSDK(config) {
         let fullReconfig = false;
         let partialReconfig = false;
@@ -62017,6 +62689,7 @@ class Nami {
         // configure SDK with new config
         __classPrivateFieldSet(this, _Nami_isInitialized, true, "f");
         NamiAPI.configure(config);
+        this.listenForAppForeground();
         await NamiRefs.instance.init(config);
         logger.info("SDK successfully initialized!");
         const state = partialReconfig || fullReconfig ? exports.RECONFIG_SUCCESS : exports.INITIAL_SUCCESS;
@@ -62028,7 +62701,7 @@ class Nami {
         };
     }
 }
-_Nami_isInitialized = new WeakMap();
+_Nami_isInitialized = new WeakMap(), _Nami_removeForegroundListener = new WeakMap();
 Nami.instance = new Nami();
 
 const VALID_STYLES = new Set(['fullscreen', 'sheet', 'compact_sheet', 'modal']);