@incodetech/tri-sdk 0.1.1 → 0.1.2-dev-20260528

package/dist/tri.umd.js

@@ -106,7 +106,7 @@
      */
     const ENV_TO_BASE_API_URL_LOOKUP = {
         STAGE_K8S: 'https://falcon-ingest-k8s.stage.incodetest.com',
-        SAAS: 'http://localhost:8080',
+        SAAS: '',
         STAGE: '',
         DEMO: '',
         DEMO_K8S: ''
@@ -267,6 +267,58 @@
         }
     }
 
+    /**
+     * @module sdk/internal/collection-status
+     *
+     * @description
+     * Preflight check — queries the backend to decide whether the SDK should load
+     * its full manager bundle for this session.
+     *
+     * ### Sanctioned `fetch` exception
+     * CLAUDE.md prohibits calling `fetch` outside `src/transport/`.  This module is
+     * the **only** approved exception outside transport, analogous to the History
+     * API wrap in the navigation collector.  The preflight runs before the transport
+     * layer exists (the lazy chunk hasn't loaded yet), so it must call fetch
+     * directly.  `_fetch` is captured at module-evaluation time to survive host-side
+     * patching of `globalThis.fetch` (same hazard model as `lib/http/http.ts`).
+     *
+     * @internal
+     */
+    const _fetch$1 = globalThis.fetch.bind(globalThis);
+    const TIMEOUT_MS = 10000;
+    /**
+     * Queries `GET {apiURL}/api/v1/events/collection-status` and returns whether the backend has
+     * collection enabled for this API key.
+     *
+     * Returns `false` on any network error, non-OK response, or timeout so that a
+     * hung or unreachable backend silently disables the SDK rather than blocking the
+     * host application.
+     */
+    async function getCollectionStatus(apiURL, apiKey) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+        try {
+            const base = apiURL.replace(/\/$/, '');
+            const response = await _fetch$1(`${base}/api/v1/events/collection-status`, {
+                method: 'GET',
+                headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey },
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                return false;
+            }
+            const data = (await response.json());
+            return Boolean(data.eventsCollectionEnabled);
+        }
+        catch (error) {
+            logger.warn('CollectionStatus', 'failed to load collection status', error);
+            return false;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+
     /**
      * Singleton entry-point for the TRI SDK.
      *
@@ -327,7 +379,7 @@
             }
             this.startState = 'starting';
             const generation = ++this.startGeneration;
-            void this.runStart(config, generation);
+            void this._start(config, generation);
         }
         /**
          * @description Stops all collectors, flushes pending events, and tears down
@@ -359,12 +411,12 @@
          * event silently (with a dev warning) if called before `start` completes.
          */
         reportEvent(name, metadata) {
-            if (this.shouldEarlyEscapeReport()) {
+            if (this._shouldEarlyEscapeReport()) {
                 return;
             }
             void safeAsync(() => this.eventReportManager.report(name, metadata));
         }
-        async runStart(config, generation) {
+        async _start(config, generation) {
             if (typeof document === 'undefined') {
                 logger.fatal('error', 'Start', 'start() called in a non-browser environment. The SDK will not start.');
                 this.startState = 'idle';
@@ -377,10 +429,15 @@
                 this.startState = 'idle';
                 return;
             }
+            const enabled = await getCollectionStatus(preflight.baseApiURL, preflight.apiKey);
             // Bail if stop() or a concurrent start() invalidated this run.
             if (this.startGeneration !== generation) {
                 return;
             }
+            if (!enabled) {
+                this.startState = 'idle';
+                return;
+            }
             // Flip DEBUG only after the SDK is confirmed to start.
             logger.DEBUG = preflight.debug;
             // Dynamically import the lazy chunk with a hard timeout so a slow/dead
@@ -433,7 +490,7 @@
          * no-op.  Guards against calling before the SDK is fully started, or when
          * the `eventReportManager` is unexpectedly absent.
          */
-        shouldEarlyEscapeReport() {
+        _shouldEarlyEscapeReport() {
             if (this.startState !== 'started') {
                 logger.warn('ReportEvent', 'reportEvent() called before start() completed.');
                 return true;
@@ -482,6 +539,58 @@
         return navigator.locks.request(lockName, { mode: 'exclusive' }, async () => safeAsync(fn));
     }
 
+    function createStorage(storageId) {
+        function hasStorage() {
+            return (globalThis.window &&
+                globalThis.window[storageId] &&
+                typeof globalThis.window[storageId] !== 'undefined');
+        }
+        function get(key) {
+            if (!hasStorage())
+                return null;
+            try {
+                const raw = window[storageId].getItem(key) ?? 'null';
+                if (raw === 'null')
+                    return null;
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        }
+        function set(key, value) {
+            if (!hasStorage())
+                return;
+            safeSync(() => window[storageId].setItem(key, JSON.stringify(value)));
+        }
+        function remove(key) {
+            if (!hasStorage())
+                return;
+            safeSync(() => window[storageId].removeItem(key));
+        }
+        function key(index) {
+            if (!hasStorage())
+                return null;
+            return window[storageId].key(index);
+        }
+        function length() {
+            if (!hasStorage())
+                return 0;
+            return window[storageId].length;
+        }
+        return {
+            get,
+            set,
+            remove,
+            key,
+            get length() {
+                return length();
+            }
+        };
+    }
+    const LocalStorage = createStorage('localStorage');
+    const SessionStorage = createStorage('sessionStorage');
+
     const KEY_TOKEN = 'activity_token';
     const KEY_ACTIVITY_ID = 'activity_id';
     const KEY_ACTIVITY_STATUS = 'activity_status';
@@ -508,11 +617,13 @@
         }
         /* Doesn't have a lock because it is called from the lifecycle manager on pagehide, if there is a lock, this won't fire */
         async stop() {
+            /** clear persisted activity state from storage - don't invalidate in-memory state
+             * because token has to survive for api.stopActivity() call, because api auth middleware uses activity.getToken() */
+            this._updatePersistedActivityState(null);
             this.startPromise = null;
             if (this.token) {
                 await this.context.stopActivity();
             }
-            await this._invalidate();
         }
         /* despite facading the this.start() method, this method is still needed
            if we decide to have separated endpoint for the token refresh */
@@ -526,7 +637,7 @@
                     this.activityStatus === 'ACTIVE') {
                     return;
                 }
-                const stored = await this._load();
+                const stored = this._load();
                 const didOtherTabRefresh = stored &&
                     stored.token !== tokenAtRequestTime &&
                     !jwt.isExpired(stored.token) &&
@@ -535,7 +646,7 @@
                     this._updateActivityState(stored);
                     return;
                 }
-                await this._invalidate();
+                this._invalidate();
                 await this._resolveStartActivity();
             });
         }
@@ -558,7 +669,7 @@
          */
         async _resolveStartActivity() {
             /* 2. try to load from persistent storage */
-            const stored = await this._load();
+            const stored = this._load();
             const shouldUsePersisted = stored &&
                 !jwt.isExpired(stored.token) &&
                 stored.activityStatus === 'ACTIVE';
@@ -569,7 +680,7 @@
             if (stored) {
                 // Stale — drop it before we fetch fresh, so a partial save below
                 // doesn't leave the old token behind.
-                await this._invalidate();
+                this._invalidate();
             }
             /* 3. if no token or token is expired, start a new activity */
             const result = await this.context.startActivity();
@@ -582,18 +693,18 @@
                 return;
             const newActivityState = result.data;
             this._updateActivityState(newActivityState);
-            await this._save(newActivityState);
-        }
-        async _load() {
-            const [token, activityId, activityStatus] = await Promise.all([
-                this.context.db.get(KEY_TOKEN),
-                this.context.db.get(KEY_ACTIVITY_ID),
-                this.context.db.get(KEY_ACTIVITY_STATUS)
-            ]);
+            this._save(newActivityState);
+        }
+        _load() {
+            const [token, activityId, activityStatus] = [
+                LocalStorage.get(KEY_TOKEN),
+                LocalStorage.get(KEY_ACTIVITY_ID),
+                LocalStorage.get(KEY_ACTIVITY_STATUS)
+            ];
             if (!token || !activityId || !activityStatus) {
                 // Partial state — clean up the orphan so future loads start fresh.
                 if (token || activityId || activityStatus) {
-                    await this._invalidate();
+                    this._invalidate();
                 }
                 return null;
             }
@@ -603,21 +714,26 @@
                 activityStatus: activityStatus
             };
         }
-        async _save(data) {
-            await Promise.all([
-                this.context.db.set(KEY_TOKEN, data.token ?? ''),
-                this.context.db.set(KEY_ACTIVITY_ID, data.activityId),
-                this.context.db.set(KEY_ACTIVITY_STATUS, data.activityStatus)
-            ]);
-        }
-        async _invalidate() {
-            await Promise.all([
-                this.context.db.remove(KEY_TOKEN),
-                this.context.db.remove(KEY_ACTIVITY_ID),
-                this.context.db.remove(KEY_ACTIVITY_STATUS)
-            ]);
+        _save(data) {
+            LocalStorage.set(KEY_TOKEN, data.token);
+            LocalStorage.set(KEY_ACTIVITY_ID, data.activityId);
+            LocalStorage.set(KEY_ACTIVITY_STATUS, data.activityStatus);
+        }
+        _invalidate() {
+            this._updatePersistedActivityState(null);
             this._updateActivityState(null);
         }
+        _updatePersistedActivityState(data) {
+            if (!data) {
+                LocalStorage.remove(KEY_TOKEN);
+                LocalStorage.remove(KEY_ACTIVITY_ID);
+                LocalStorage.remove(KEY_ACTIVITY_STATUS);
+                return;
+            }
+            LocalStorage.set(KEY_TOKEN, data.token);
+            LocalStorage.set(KEY_ACTIVITY_ID, data.activityId);
+            LocalStorage.set(KEY_ACTIVITY_STATUS, data.activityStatus);
+        }
         _updateActivityState(data) {
             if (!data) {
                 this.token = null;
@@ -645,7 +761,7 @@
      */
     const WIRE = {
         /** Injected at build time from package.json `version` via @rollup/plugin-replace. */
-        sdkVersion: "0.1.1",
+        sdkVersion: "0.1.2-dev-20260528",
         /** Injected at build time via @rollup/plugin-replace. Bump when the wire schema changes. */
         schemaVersion: "0.1.0",
         sdkPlatform: 'web',
@@ -1198,8 +1314,11 @@
         /**
          * Returns whether a failed `HttpResult` is worth retrying.
          *
-         * - `network` / `timeout`: transient transport issue.
-         * - `server` / `rate_limited`: backend asked us to back off.
+         * - `timeout` / `server` / `rate_limited`: transient or back-pressure
+         *   failure — the backend may recover; retry with backoff.
+         * - `network`: connection-level failure. Intentionally non-retryable: the
+         *   `onConnectionChange()` offline path preserves the queue and re-arms the
+         *   drain when connectivity returns, making a separate retry redundant.
          * - `abort`: deliberate cancellation; retrying defeats the cancel.
          * - `client` / `parse` / `serialize`: our bug; the next attempt will
          *   produce the same result. Drop the batch.
@@ -1228,58 +1347,6 @@
         }
     }
 
-    function createStorage(storageId) {
-        function hasStorage() {
-            return (globalThis.window &&
-                globalThis.window[storageId] &&
-                typeof globalThis.window[storageId] !== 'undefined');
-        }
-        function get(key) {
-            if (!hasStorage())
-                return null;
-            try {
-                const raw = window[storageId].getItem(key) ?? 'null';
-                if (raw === 'null')
-                    return null;
-                return JSON.parse(raw);
-            }
-            catch {
-                return null;
-            }
-        }
-        function set(key, value) {
-            if (!hasStorage())
-                return;
-            safeSync(() => window[storageId].setItem(key, JSON.stringify(value)));
-        }
-        function remove(key) {
-            if (!hasStorage())
-                return;
-            safeSync(() => window[storageId].removeItem(key));
-        }
-        function key(index) {
-            if (!hasStorage())
-                return null;
-            return window[storageId].key(index);
-        }
-        function length() {
-            if (!hasStorage())
-                return 0;
-            return window[storageId].length;
-        }
-        return {
-            get,
-            set,
-            remove,
-            key,
-            get length() {
-                return length();
-            }
-        };
-    }
-    const LocalStorage = createStorage('localStorage');
-    const SessionStorage = createStorage('sessionStorage');
-
     /**
      * @module storage-event-channel
      *
@@ -4291,7 +4358,7 @@
         }
         /** @description Stops an activity and returns a result — authenticated endpoint */
         async function stopActivity() {
-            return authMiddleware.withAuth((token) => http.post('/stop-activity', { token, keepalive: true }), { refreshable: false });
+            return authMiddleware.withAuth((token) => http.post('/end-activity', { token, keepalive: true }), { refreshable: false });
         }
         /** @description Ingests a batch of events — authenticated endpoint */
         async function ingest(payload, keepalive) {
@@ -4368,507 +4435,6 @@
         }
     }
 
-    /**
-     * Internal RFC6265-compliant cookie utility.
-     *
-     * Encoding is intentionally bit-for-bit compatible with js-cookie v3.0.7 so
-     * that cookies written by earlier SDK versions (which used js-cookie directly)
-     * continue to decode correctly after upgrading to this implementation.
-     *
-     * The module is internal-only and must not be re-exported from src/index.ts.
-     *
-     * @module
-     */
-    /**
-     * Encodes a cookie value using the js-cookie v3 RFC6265 scheme:
-     *  1. `encodeURIComponent` percent-encodes everything except `A–Z a–z 0–9 - _ . ! ~ * ' ( )`.
-     *  2. A second pass un-escapes the RFC6265 cookie-octet whitelist characters
-     *     that are safe to transmit without encoding:
-     *     `# $ & + / : < = > ? @ [ ] ^ \` { | }`.
-     *  3. Semicolons (`;`) remain percent-encoded because they act as the cookie
-     *     attribute separator and must not appear unescaped in a value.
-     */
-    function encodeValue(value) {
-        return encodeURIComponent(value).replace(/%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/gi, decodeURIComponent);
-    }
-    /**
-     * Encodes a cookie name using the js-cookie v3 RFC6265 scheme:
-     *  1. `encodeURIComponent` percent-encodes the name.
-     *  2. A second pass un-escapes the RFC6265 cookie-name token whitelist:
-     *     `# $ & + ^ \` |`.
-     *  3. `(` and `)` are left as `%28` / `%29`; raw parentheses are disallowed in
-     *     cookie names per the spec, and js-cookie explicitly re-encodes them via
-     *     the deprecated global `escape()` which produces the same result.
-     */
-    function encodeName(name) {
-        return encodeURIComponent(name)
-            .replace(/%(2[346B]|5E|60|7C)/gi, decodeURIComponent)
-            .replace(/[()]/g, (char) => (char === '(' ? '%28' : '%29'));
-    }
-    /**
-     * Decodes a cookie value using the js-cookie v3 scheme.
-     *
-     * Strips a surrounding pair of double quotes (some Set-Cookie implementations
-     * wrap values in quotes), then replaces runs of percent-encoded bytes with
-     * their decoded form. Mirrors js-cookie's per-sequence try/catch fallback so
-     * that malformed percent-sequences in cookies written by other parties degrade
-     * to the raw string rather than throwing.
-     */
-    function decodeValue(raw) {
-        let value = raw;
-        if (value[0] === '"') {
-            value = value.slice(1, -1);
-        }
-        return value.replace(/(%[\dA-F]{2})+/gi, (sequence) => {
-            try {
-                return decodeURIComponent(sequence);
-            }
-            catch {
-                return sequence;
-            }
-        });
-    }
-    /**
-     * Serialises `CookieAttributes` into the `; Key=Value` fragment appended to
-     * the `name=value` pair written to `document.cookie`.
-     */
-    function serializeAttributes(attributes) {
-        let result = '';
-        if (attributes.expires !== undefined) {
-            let expiresDate;
-            if (attributes.expires instanceof Date) {
-                expiresDate = attributes.expires;
-            }
-            else {
-                expiresDate = new Date(Date.now() + attributes.expires * 864e5);
-            }
-            result += '; Expires=' + expiresDate.toUTCString();
-        }
-        if (attributes.path !== undefined) {
-            result += '; Path=' + attributes.path;
-        }
-        if (attributes.domain !== undefined) {
-            result += '; Domain=' + attributes.domain;
-        }
-        if (attributes.sameSite !== undefined) {
-            const capitalised = attributes.sameSite.charAt(0).toUpperCase() +
-                attributes.sameSite.slice(1);
-            result += '; SameSite=' + capitalised;
-        }
-        if (attributes.secure === true) {
-            result += '; Secure';
-        }
-        return result;
-    }
-    /**
-     * Reads a cookie by name from `document.cookie`.
-     *
-     * Decoding mirrors js-cookie v3 exactly:
-     *  - Segments are split on `'; '`.
-     *  - Each segment is split on the **first** `=`.
-     *  - The name is decoded with plain `decodeURIComponent`.
-     *  - The value is decoded with the js-cookie percent-sequence approach (see
-     *    `decodeValue`).
-     *
-     * Returns `undefined` when the cookie is absent or when `document` is not
-     * available in the current environment.
-     */
-    function getCookie(name) {
-        if (typeof document === 'undefined')
-            return undefined;
-        const cookies = document.cookie ? document.cookie.split('; ') : [];
-        for (const cookie of cookies) {
-            const separatorIndex = cookie.indexOf('=');
-            if (separatorIndex === -1)
-                continue;
-            const rawName = cookie.slice(0, separatorIndex);
-            let decodedName;
-            try {
-                decodedName = decodeURIComponent(rawName);
-            }
-            catch {
-                decodedName = rawName;
-            }
-            if (decodedName === name) {
-                const rawValue = cookie.slice(separatorIndex + 1);
-                return decodeValue(rawValue);
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Writes a cookie to `document.cookie`.
-     *
-     * Name and value encoding mirrors js-cookie v3 exactly (see `encodeName` and
-     * `encodeValue`). No-ops silently when `document` is not available.
-     */
-    function setCookie(name, value, attributes = {}) {
-        if (typeof document === 'undefined')
-            return;
-        document.cookie =
-            encodeName(name) +
-                '=' +
-                encodeValue(value) +
-                serializeAttributes(attributes);
-    }
-    /**
-     * Removes a cookie by expiring it one day in the past.
-     *
-     * Mirrors js-cookie v3's removal approach (`expires: -1`). The `path` and
-     * `domain` attributes must match those used when the cookie was written;
-     * mismatches silently leave the cookie in place.
-     */
-    function removeCookie(name, attributes = {}) {
-        setCookie(name, '', { ...attributes, expires: -1 });
-    }
-
-    /**
-     * Hard cap on cookie size. Browsers vary slightly (the spec is 4096 bytes
-     * including name, value, and attributes), but ~4000 leaves headroom for
-     * the attribute serialization.
-     */
-    const COOKIE_BYTE_BUDGET = 4000;
-    /**
-     * Cookie storage adapter backed by `document.cookie`.
-     *
-     * Cookies are durable across tabs and survive localStorage clears, but they're
-     * capped at ~4KB per cookie and ~50 cookies per domain — large values are
-     * rejected rather than silently truncated so the orchestrator can degrade
-     * gracefully.
-     *
-     * Encoding is bit-for-bit compatible with js-cookie v3 (RFC6265) so that
-     * cookies written by earlier SDK versions continue to read correctly.
-     */
-    class CookieStorage {
-        constructor(options = {}) {
-            this.name = 'cookies';
-            this.attrs = CookieStorage.getCookieAttributes(options);
-            if (options.domain)
-                this.attrs.domain = options.domain;
-        }
-        /**
-         * `navigator.cookieEnabled` returns true even in some embedded contexts
-         * where third-party cookie writes silently fail, so we round-trip a probe.
-         */
-        async isAvailable() {
-            if (typeof document === 'undefined' ||
-                (typeof navigator !== 'undefined' && navigator.cookieEnabled === false))
-                return false;
-            try {
-                const probeKey = `__immortal_probe_${generateUUID()}__`;
-                safeSync(() => setCookie(probeKey, '1', { path: '/' }));
-                const ok = safeSync(() => getCookie(probeKey)) === '1';
-                safeSync(() => removeCookie(probeKey, { path: '/' }));
-                return ok;
-            }
-            catch {
-                return false;
-            }
-        }
-        async get(key) {
-            const value = safeSync(() => getCookie(key));
-            return value === undefined ? null : value;
-        }
-        async set(key, value) {
-            if (key.length + value.length > COOKIE_BYTE_BUDGET) {
-                throw new Error(`CookieStorage: combined key+value size (${key.length + value.length}) ` +
-                    `exceeds budget (${COOKIE_BYTE_BUDGET}) for key "${key}"`);
-            }
-            safeSync(() => setCookie(key, value, this.attrs));
-        }
-        async remove(key) {
-            // Path must match the original write to actually clear the cookie.
-            safeSync(() => removeCookie(key, {
-                path: this.attrs.path,
-                domain: this.attrs.domain,
-            }));
-        }
-        static getCookieAttributes(options) {
-            return {
-                expires: options.expires ?? 365,
-                path: options.path ?? '/',
-                sameSite: options.sameSite ?? 'lax',
-                secure: options.secure ?? false,
-            };
-        }
-    }
-
-    /**
-     * Adapter over IndexedDB. Single object store keyed by string, value is
-     * a string. The DB handle is opened lazily on first operation and cached
-     * on the instance — failed opens are not cached so the next call retries.
-     *
-     * Transaction completion (not just request success) is awaited for writes,
-     * since `request.onsuccess` can fire before a transaction has actually
-     * committed in some browsers.
-     */
-    class IndexedDBStorage {
-        constructor(options = {}) {
-            this.name = 'indexedDB';
-            this.dbPromise = null;
-            this.dbName = options.dbName ?? 'tri:_immortal_db';
-            this.storeName = options.storeName ?? 'tri:kv';
-            this.version = options.version ?? 1;
-        }
-        async isAvailable() {
-            if (typeof indexedDB === 'undefined')
-                return false;
-            try {
-                await this.open();
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
-        async get(key) {
-            const result = await this.tx('readonly', (s) => s.get(key));
-            if (result === undefined || result === null)
-                return null;
-            return typeof result === 'string' ? result : String(result);
-        }
-        async set(key, value) {
-            await this.tx('readwrite', (s) => s.put(value, key));
-        }
-        async remove(key) {
-            await this.tx('readwrite', (s) => s.delete(key));
-        }
-        open() {
-            if (this.dbPromise)
-                return this.dbPromise;
-            const promise = new Promise((resolve, reject) => {
-                if (typeof indexedDB === 'undefined') {
-                    reject(new Error('IndexedDB is not available in this environment'));
-                    return;
-                }
-                const req = indexedDB.open(this.dbName, this.version);
-                req.onerror = () => reject(req.error);
-                req.onblocked = () => reject(new Error('IndexedDB open blocked'));
-                req.onsuccess = () => resolve(req.result);
-                req.onupgradeneeded = () => {
-                    const db = req.result;
-                    if (!db.objectStoreNames.contains(this.storeName)) {
-                        db.createObjectStore(this.storeName);
-                    }
-                };
-            });
-            // Don't cache a rejected promise — let the next call retry from scratch.
-            promise.catch(() => {
-                if (this.dbPromise === promise)
-                    this.dbPromise = null;
-            });
-            this.dbPromise = promise;
-            return promise;
-        }
-        async tx(mode, fn) {
-            return this.open().then((db) => new Promise((resolve, reject) => {
-                const tx = db.transaction(this.storeName, mode);
-                const objectStore = tx.objectStore(this.storeName);
-                const req = fn(objectStore);
-                let result;
-                req.onsuccess = () => {
-                    result = req.result;
-                };
-                req.onerror = () => reject(req.error);
-                tx.oncomplete = () => resolve(result);
-                tx.onerror = () => reject(tx.error);
-                tx.onabort = () => reject(tx.error ?? new Error('IndexedDB transaction aborted'));
-            }));
-        }
-    }
-
-    /**
-     * Adapter for the Web Storage API (localStorage / sessionStorage).
-     * The underlying Storage instance is injected via constructor so the same
-     * class can serve both — pass `window.localStorage` or `window.sessionStorage`.
-     */
-    class WebStorage {
-        constructor(storage, name) {
-            this.storage = storage;
-            this.name = name;
-        }
-        /**
-         * Probe via write/read/delete of a sentinel key. Catches:
-         *   - Safari private mode (throws on setItem)
-         *   - Storage disabled by user / policy
-         *   - Quota-exhausted state
-         * `typeof Storage !== 'undefined'` alone is unreliable.
-         */
-        async isAvailable() {
-            try {
-                const probeKey = `__immortal_probe_${generateUUID()}__`;
-                safeSync(() => this.storage.setItem(probeKey, '1'));
-                const ok = safeSync(() => this.storage.getItem(probeKey)) === '1';
-                safeSync(() => this.storage.removeItem(probeKey));
-                return ok;
-            }
-            catch {
-                return false;
-            }
-        }
-        async get(key) {
-            return safeSync(() => this.storage.getItem(key)) ?? null;
-        }
-        async set(key, value) {
-            safeSync(() => this.storage.setItem(key, value));
-        }
-        async remove(key) {
-            safeSync(() => this.storage.removeItem(key));
-        }
-    }
-
-    /**
-     * Redundant key-value store fanning out across multiple storage backends.
-     *
-     * - `set` / `remove` fan out to every available backend in parallel; per-store
-     *   failures are logged via `onError` but do not fail the operation.
-     * - `get` reads from all backends in parallel and resolves divergence by
-     *   majority vote, with non-null preferred on ties (a present value is
-     *   stronger evidence than absence) and earlier-configured stores winning
-     *   further ties.
-     * - After every read, any backend whose value differs from the winner is
-     *   healed via a corrective write (fire-and-forget — does not block the read).
-     */
-    let ImmortalDB$1 = class ImmortalDB {
-        constructor(options = {}) {
-            this._stores = [];
-            this._initialized = false;
-            this._initPromise = null;
-            this._configured = options.stores ?? ImmortalDB._defaultStores();
-            this._keyPrefix = options.keyPrefix ?? '_tri_immortal_';
-            this._onError = options.onError ?? (() => { });
-        }
-        /** Names of backends that passed availability probing. Useful for diagnostics. */
-        get activeStores() {
-            return this._stores.map((s) => s.name);
-        }
-        /**
-         * Probe configured backends in parallel and retain only the live ones.
-         * Idempotent: subsequent calls are no-ops; concurrent calls share the
-         * same promise so probes only run once.
-         */
-        async init() {
-            if (this._initialized)
-                return;
-            if (this._initPromise)
-                return this._initPromise;
-            this._initPromise = (async () => {
-                const probes = await Promise.allSettled(this._configured.map(async (store) => ({
-                    store,
-                    ok: await store.isAvailable()
-                })));
-                this._stores = probes.reduce((acc, p) => {
-                    if (p.status === 'fulfilled' && p.value.ok) {
-                        acc.push(p.value.store);
-                    }
-                    return acc;
-                }, []);
-                if (this._stores.length === 0 && true) {
-                    throw new Error('ImmortalDB: no storage backends are available');
-                }
-                this._initialized = true;
-            })();
-            try {
-                await this._initPromise;
-            }
-            finally {
-                this._initPromise = null;
-            }
-        }
-        async get(key) {
-            await this._ensureInitialized();
-            const namespacedKey = this._namespace(key);
-            const reads = await Promise.allSettled(this._stores.map((s) => s.get(namespacedKey)));
-            // Map each store to its observed value, treating rejections as "missing".
-            const observations = reads.map((r, i) => {
-                if (r.status === 'fulfilled')
-                    return { store: this._stores[i], value: r.value };
-                this._onError(this._stores[i].name, 'get', r.reason);
-                return { store: this._stores[i], value: null };
-            });
-            const winner = ImmortalDB._pickWinner(observations);
-            // Self-heal divergent backends. Fire-and-forget — don't block the read.
-            for (const { store, value } of observations) {
-                if (value === winner)
-                    continue;
-                winner === null
-                    ? store
-                        .remove(namespacedKey)
-                        .catch((e) => this._onError(store.name, 'heal-remove', e))
-                    : store
-                        .set(namespacedKey, winner)
-                        .catch((e) => this._onError(store.name, 'heal-set', e));
-            }
-            return winner;
-        }
-        async set(key, value) {
-            await this._ensureInitialized();
-            const namespacedKey = this._namespace(key);
-            const writes = await Promise.allSettled(this._stores.map((s) => s.set(namespacedKey, value)));
-            writes.forEach((w, i) => {
-                if (w.status === 'rejected')
-                    this._onError(this._stores[i].name, 'set', w.reason);
-            });
-        }
-        async remove(key) {
-            await this._ensureInitialized();
-            const namespacedKey = this._namespace(key);
-            const removes = await Promise.allSettled(this._stores.map((s) => s.remove(namespacedKey)));
-            removes.forEach((r, i) => {
-                if (r.status === 'rejected')
-                    this._onError(this._stores[i].name, 'remove', r.reason);
-            });
-        }
-        _namespace(key) {
-            return `${this._keyPrefix}${key}`;
-        }
-        async _ensureInitialized() {
-            if (!this._initialized)
-                await this.init();
-        }
-        /**
-         * Pick the canonical value from a set of observations.
-         * Rules:
-         *   1. Highest vote count wins.
-         *   2. On tie between null and non-null, prefer non-null
-         *      (a present value is stronger evidence than absence).
-         *   3. On further tie, the earliest-configured store wins
-         *      (deterministic, predictable from `stores` ordering).
-         */
-        static _pickWinner(observations) {
-            const counts = new Map();
-            for (const { value } of observations) {
-                counts.set(value, (counts.get(value) ?? 0) + 1);
-            }
-            const maxCount = Math.max(...counts.values());
-            const tied = observations.filter((o) => counts.get(o.value) === maxCount);
-            // Prefer the first non-null observation among the tied; fall back to null.
-            const firstNonNull = tied.find((o) => o.value !== null);
-            return firstNonNull ? firstNonNull.value : null;
-        }
-        static _defaultStores() {
-            const stores = [];
-            if (typeof window !== 'undefined') {
-                try {
-                    if (window.localStorage)
-                        stores.push(new WebStorage(window.localStorage, 'localStorage'));
-                }
-                catch {
-                    // Accessing window.localStorage can throw in some sandboxed contexts.
-                }
-            }
-            if (typeof document !== 'undefined') {
-                stores.push(new CookieStorage());
-            }
-            if (typeof indexedDB !== 'undefined') {
-                stores.push(new IndexedDBStorage());
-            }
-            return stores;
-        }
-    };
-
-    const ImmortalDB = new ImmortalDB$1();
-
     const INTERACTIVE_TAGS = new Set([
         'A',
         'BUTTON',
@@ -5883,8 +5449,7 @@
             /** Activity Manager */
             activityManagerRef = new ActivityManager({
                 startActivity: () => falconServiceManagerRef.api.startActivity(),
-                stopActivity: () => falconServiceManagerRef.api.stopActivity(),
-                db: ImmortalDB
+                stopActivity: () => falconServiceManagerRef.api.stopActivity()
             });
             await activityManagerRef.start();
             /** Transport Manager */