@incodetech/tri-sdk 0.1.0 → 0.1.1

package/dist/tri.umd.js

@@ -4,26 +4,191 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.TRI = factory());
 })(this, (function () { 'use strict';
 
-    function decode(token) {
-        if (!token)
-            return null;
-        const payload = token.split('.')[1];
-        const json = atob(payload.replace(/-/g, '+').replace(/_/g, '/'));
-        return JSON.parse(json);
-    }
-    function isExpired(token, skewSeconds = 30) {
-        if (!token)
-            return true;
-        const payload = decode(token);
-        if (!payload || typeof payload.exp !== 'number') {
-            return true;
+    /**
+     * @module lib/logger
+     *
+     * @description
+     * Singleton logger for the TRI SDK. This is the **only** sanctioned site for
+     * `console.*` calls inside `packages/core`. All other modules must import and
+     * use the exported `logger` instance rather than calling `console` directly.
+     *
+     * ### Debug gating
+     * Non-fatal methods (`warn`, `error`, `info`) are no-ops when `DEBUG` is
+     * `false`. Set `logger.DEBUG = true` — typically driven by the `debug` field
+     * in `TRIConfig` — to activate them. No string concatenation happens in the
+     * fast path (early return before any allocation).
+     *
+     * `fatal` always emits regardless of `DEBUG`; use it only for messages that
+     * must surface in production (hard misconfigurations, blocked environments).
+     *
+     * ### Message format
+     * `[prefix] message` — prefix is wrapped in square brackets and prepended to
+     * the message with a single space. Extra `args` are forwarded to the underlying
+     * `console.*` method unchanged so error objects and context values render with
+     * full browser-console expansion.
+     */
+    const SDK_PREFIX = 'TRI';
+    class Logger {
+        constructor() {
+            this.debugValue = false;
+        }
+        /** Returns the singleton Logger instance. */
+        static get instance() {
+            if (!Logger.singleton) {
+                Logger.singleton = new Logger();
+            }
+            return Logger.singleton;
+        }
+        /** Exposed read-only view of the current debug state. */
+        get _DEBUG() {
+            return this.debugValue;
+        }
+        get DEBUG() {
+            return this.debugValue;
+        }
+        set DEBUG(value) {
+            this.debugValue = value;
+        }
+        /** @inheritdoc LoggerInterface.warn */
+        warn(prefix, message, ...args) {
+            if (!this.debugValue)
+                return;
+            this._log('warn', prefix, message, ...args);
+        }
+        /** @inheritdoc LoggerInterface.error */
+        error(prefix, message, ...args) {
+            if (!this.debugValue)
+                return;
+            this._log('error', prefix, message, ...args);
+        }
+        /** @inheritdoc LoggerInterface.info */
+        info(prefix, message, ...args) {
+            if (!this.debugValue)
+                return;
+            this._log('info', prefix, message, ...args);
+        }
+        /** @inheritdoc LoggerInterface.fatal */
+        fatal(level, prefix, message, ...args) {
+            this._log(level, prefix, message, ...args);
+        }
+        _log(level, prefix, message, ...args) {
+            const modulePrefix = prefix ? `[${prefix}]` : '';
+            console[level](`[${SDK_PREFIX}]${modulePrefix} ${message}`, ...args);
         }
-        return payload.exp * 1000 <= Date.now() + skewSeconds * 1000;
     }
-    const jwt = {
-        decode,
-        isExpired
+    /** Singleton logger instance. Import and use this throughout `packages/core`. */
+    const logger = Logger.instance;
+
+    /**
+     * @module sdk/internal/env
+     *
+     * @description
+     * Environment constants and URL resolver for the SDK preflight.  This module
+     * is part of the **static bundle** — it imports only primitive types and the
+     * logger singleton, so it carries no collector-factory cost.
+     *
+     * Anything that must run before the lazy chunk loads (e.g. `sdk.ts` deciding
+     * whether to even fetch the bundle) should import from here rather than from
+     * the full `sdk/constants` module.
+     *
+     * @internal
+     */
+    /** How long (ms) to wait for a dynamic `import()` before giving up. */
+    const DYNAMIC_IMPORT_TIMEOUT_MS = 10000;
+    /** Default value for the `debug` flag when the host omits it. */
+    const DEFAULT_DEBUG = false;
+    /** Default `apiVersion` string when the host omits it. */
+    const DEFAULT_API_VERSION = '1.0';
+    /**
+     * Lookup from a `TriEnv` value to its corresponding base API URL.
+     * Entries with an empty string are **not yet provisioned**; hosts attempting
+     * to use them will receive a fatal error at SDK start.
+     */
+    const ENV_TO_BASE_API_URL_LOOKUP = {
+        STAGE_K8S: 'https://falcon-ingest-k8s.stage.incodetest.com',
+        SAAS: 'http://localhost:8080',
+        STAGE: '',
+        DEMO: '',
+        DEMO_K8S: ''
     };
+    /**
+     * All known `TriEnv` keys (including those not yet provisioned with a URL).
+     * Used to distinguish a typo/unsupported env from a known-but-unprovisioned one.
+     */
+    const SUPPORTED_ENVS = Object.keys(ENV_TO_BASE_API_URL_LOOKUP);
+    /**
+     * Base API URLs that are fully provisioned and accepted at SDK start.
+     * Derived from `ENV_TO_BASE_API_URL_LOOKUP` by filtering empty strings.
+     */
+    const SUPPORTED_API_URLS = Object.values(ENV_TO_BASE_API_URL_LOOKUP).filter(Boolean);
+    /**
+     * Resolves a `TriEnv` value to its base API URL.
+     *
+     * Returns `undefined` (and logs a fatal) when:
+     *  - the env is not a known `TriEnv` key, or
+     *  - the env is known but not yet provisioned (empty URL).
+     */
+    function resolveBaseApiURLFromEnv(env) {
+        if (!SUPPORTED_ENVS.includes(env)) {
+            logger.fatal('error', 'SDK', 'Provided environment is not supported:', env, 'Supported environments are:', SUPPORTED_ENVS.join(', '));
+            return undefined;
+        }
+        const url = ENV_TO_BASE_API_URL_LOOKUP[env];
+        if (!url) {
+            logger.fatal('error', 'SDK', `env "${env}" is not yet provisioned with a base URL.`);
+            return undefined;
+        }
+        return url;
+    }
+
+    /**
+     * @module sdk/internal/preflight-config
+     *
+     * @description
+     * Lightweight config validator that runs in the **static bundle** before the
+     * lazy chunk is ever fetched.  Its only job is to extract the three values
+     * needed for the collection-status preflight check (`apiKey`, `baseApiURL`,
+     * `debug`) and return them — or log a fatal and return `null` when the host
+     * config is unusable.
+     *
+     * The full `resolveTRIConfig` function (in `sdk/helpers.ts`) performs a
+     * superset of this validation and lives in the lazy chunk.  This module exists
+     * solely to keep the static bundle free of `COLLECTORS_CONFIG` and every
+     * transitively-imported collector factory.
+     *
+     * @internal
+     */
+    /**
+     * Extracts and validates the preflight-critical fields from the host-supplied
+     * config.  Returns `null` (with a fatal log) when any required field is missing
+     * or the resolved URL is not provisioned.
+     */
+    function resolvePreflightConfig(config) {
+        if (!config?.apiKey) {
+            logger.fatal('error', 'SDK', 'apiKey is required.');
+            return null;
+        }
+        let baseApiURL;
+        if (config.apiURL) {
+            if (!SUPPORTED_API_URLS.includes(config.apiURL)) {
+                logger.fatal('error', 'SDK', 'Provided apiURL is not supported:', config.apiURL, 'Supported API URLs are:', SUPPORTED_API_URLS.join(', '));
+                return null;
+            }
+            baseApiURL = config.apiURL;
+        }
+        else if (config.env) {
+            baseApiURL = resolveBaseApiURLFromEnv(config.env);
+        }
+        if (!baseApiURL) {
+            logger.fatal('error', 'SDK', "Couldn't initialise SDK — neither apiURL nor env were provided, or the provided value has no provisioned URL.");
+            return null;
+        }
+        return {
+            apiKey: config.apiKey,
+            baseApiURL,
+            debug: config.debug ?? DEFAULT_DEBUG,
+        };
+    }
 
     function addEventListener(target, type, listener) {
         let resolvedTarget = target;
@@ -62,10 +227,7 @@
             return fn();
         }
         catch (error) {
-            {
-                // eslint-disable-next-line no-console
-                console.warn('[TriSDK] safeSync swallowed error:', error);
-            }
+            logger.warn('utils', 'safeSync swallowed error:', error);
         }
         finally {
         }
@@ -75,10 +237,7 @@
             return await fn();
         }
         catch (error) {
-            {
-                // eslint-disable-next-line no-console
-                console.warn('[TriSDK] safeAsync swallowed error:', error);
-            }
+            logger.warn('utils', 'safeAsync swallowed error:', error);
         }
     }
     function safeListener(fn) {
@@ -90,17 +249,225 @@
                 fn(...args);
             }
             catch (error) {
-                {
-                    // eslint-disable-next-line no-console
-                    console.warn('[TriSDK] safeTimer swallowed error:', error);
-                }
+                logger.warn('utils', 'safeTimer swallowed error:', error);
             }
         };
     }
     function safeSetTimeout(fn, delay) {
-        const id = _setTimeout(safeTimer(fn), delay);
-        return () => _clearTimeout(id);
+        return _setTimeout(safeTimer(fn), delay);
+    }
+    function safeClearTimeout(id) {
+        if (id === null)
+            return;
+        try {
+            _clearTimeout(id);
+        }
+        catch (error) {
+            logger.warn('utils', 'safeClearTimeout swallowed error:', error);
+        }
+    }
+
+    /**
+     * Singleton entry-point for the TRI SDK.
+     *
+     * Obtain the instance via `TRI.instance`; the constructor is private.
+     *
+     * ### Life-cycle states
+     * The instance moves through three states:
+     *  - `'idle'`     — not started, or fully stopped.
+     *  - `'starting'` — `start()` has been called; preflight and lazy bundle load in progress.
+     *  - `'started'`  — all managers are running and `reportEvent()` is active.
+     *
+     * ### Never throws
+     * All public methods are fire-and-forget. Errors are logged via `logger` and
+     * swallowed so the host application is never disrupted.
+     *
+     * ### Bundle split
+     * Only the preflight config validator and collection-status check live in the
+     * static bundle. The full manager wiring (`internal/start.ts`) is dynamically
+     * imported only when the backend confirms collection is enabled, keeping the
+     * initial page-load cost minimal.
+     */
+    let TRI$1 = class TRI {
+        constructor() {
+            /**
+             * Monotonically-increasing counter incremented by every `start()` and
+             * `stop()` call. Each in-flight `runStart` captures its own generation value
+             * and bails out after every `await` if the counter has moved on, preventing
+             * orphaned manager instances from being installed after a concurrent stop.
+             */
+            this.startGeneration = 0;
+            this.startState = 'idle';
+            // All manager fields are set after the lazy chunk loads successfully.
+            this.falconServiceManager = null;
+            this.activityManager = null;
+            this.transportManager = null;
+            this.tabManager = null;
+            this.lifecycleManager = null;
+            this.collectorManager = null;
+            this.eventReportManager = null;
+        }
+        static get instance() {
+            if (!TRI._instance) {
+                TRI._instance = new TRI();
+            }
+            return TRI._instance;
+        }
+        /**
+         * @description Starts the TRI SDK. Fire-and-forget and idempotent — a second
+         * call while the SDK is starting or already started is a no-op. Checks the
+         * backend `/collection-status` endpoint and only loads the full manager bundle
+         * when collection is enabled. Safe to call in SSR environments; if `document`
+         * is unavailable the function logs a fatal and returns without throwing.
+         */
+        start(config) {
+            if (this.startState !== 'idle') {
+                logger.warn('Start', 'start() called more than once — ignoring.');
+                return;
+            }
+            this.startState = 'starting';
+            const generation = ++this.startGeneration;
+            void this.runStart(config, generation);
+        }
+        /**
+         * @description Stops all collectors, flushes pending events, and tears down
+         * every manager. Safe to call more than once. After `stop()`, `start()` may be
+         * called again with a fresh config. Any in-flight `start()` is cancelled at
+         * the next async checkpoint.
+         */
+        stop() {
+            ++this.startGeneration;
+            this.startState = 'idle';
+            this.lifecycleManager?.stop();
+            this.lifecycleManager = null;
+            this.activityManager?.stop();
+            this.activityManager = null;
+            this.transportManager?.stop();
+            this.transportManager = null;
+            this.tabManager?.stop();
+            this.tabManager = null;
+            this.collectorManager?.stop();
+            this.collectorManager = null;
+            this.eventReportManager?.stop();
+            this.eventReportManager = null;
+            this.falconServiceManager = null;
+            logger.DEBUG = DEFAULT_DEBUG;
+        }
+        /**
+         * @description Reports a host-defined event to the TRI backend. Fire-and-forget —
+         * never throws and never returns a promise the host must handle. Drops the
+         * event silently (with a dev warning) if called before `start` completes.
+         */
+        reportEvent(name, metadata) {
+            if (this.shouldEarlyEscapeReport()) {
+                return;
+            }
+            void safeAsync(() => this.eventReportManager.report(name, metadata));
+        }
+        async runStart(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';
+                return;
+            }
+            // resolvePreflightConfig runs entirely in the static bundle — no collector
+            // factories are loaded at this point.
+            const preflight = resolvePreflightConfig(config);
+            if (!preflight) {
+                this.startState = 'idle';
+                return;
+            }
+            // Bail if stop() or a concurrent start() invalidated this run.
+            if (this.startGeneration !== generation) {
+                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
+            // CDN does not hang the host application indefinitely.
+            let startModule;
+            try {
+                startModule = await Promise.race([
+                    Promise.resolve().then(function () { return start$1; }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('dynamic import timed out')), DYNAMIC_IMPORT_TIMEOUT_MS))
+                ]);
+            }
+            catch (error) {
+                logger.error('Start', 'Failed to load manager bundle:', error);
+                if (this.startGeneration === generation) {
+                    this.startState = 'idle';
+                }
+                return;
+            }
+            if (this.startGeneration !== generation) {
+                return;
+            }
+            // The lazy chunk receives the raw config and runs the full resolver internally.
+            const managers = await startModule.start(config);
+            if (this.startGeneration !== generation) {
+                // A concurrent stop() (or new start()) raced us — discard what we built.
+                if (managers) {
+                    managers.lifecycleManager?.stop();
+                    managers.tabManager?.stop();
+                    managers.transportManager?.stop();
+                    void managers.activityManager?.stop();
+                }
+                return;
+            }
+            if (!managers) {
+                // internal/start.ts already logged the reason.
+                this.startState = 'idle';
+                return;
+            }
+            this.falconServiceManager = managers.falconServiceManager;
+            this.activityManager = managers.activityManager;
+            this.transportManager = managers.transportManager;
+            this.tabManager = managers.tabManager;
+            this.lifecycleManager = managers.lifecycleManager;
+            this.collectorManager = managers.collectorManager;
+            this.eventReportManager = managers.eventReportManager;
+            this.startState = 'started';
+        }
+        /**
+         * Returns `true` (and logs a dev warning) when `reportEvent()` should be a
+         * no-op.  Guards against calling before the SDK is fully started, or when
+         * the `eventReportManager` is unexpectedly absent.
+         */
+        shouldEarlyEscapeReport() {
+            if (this.startState !== 'started') {
+                logger.warn('ReportEvent', 'reportEvent() called before start() completed.');
+                return true;
+            }
+            if (!this.eventReportManager) {
+                logger.warn('ReportEvent', 'eventReportManager not available.');
+                return true;
+            }
+            return false;
+        }
+    };
+
+    const TRI = TRI$1.instance;
+
+    function decode(token) {
+        if (!token)
+            return null;
+        const payload = token.split('.')[1];
+        const json = atob(payload.replace(/-/g, '+').replace(/_/g, '/'));
+        return JSON.parse(json);
+    }
+    function isExpired(token, skewSeconds = 30) {
+        if (!token)
+            return true;
+        const payload = decode(token);
+        if (!payload || typeof payload.exp !== 'number') {
+            return true;
+        }
+        return payload.exp * 1000 <= Date.now() + skewSeconds * 1000;
     }
+    const jwt = {
+        decode,
+        isExpired
+    };
 
     function isNativeWebLocksAvailable() {
         return (globalThis.navigator &&
@@ -114,19 +481,6 @@
         }
         return navigator.locks.request(lockName, { mode: 'exclusive' }, async () => safeAsync(fn));
     }
-    async function withSharedWebLock(lockName, fn) {
-        if (!isNativeWebLocksAvailable()) {
-            return safeAsync(fn);
-        }
-        return navigator.locks.request(lockName, { mode: 'shared' }, async () => safeAsync(fn));
-    }
-    async function queryWebLockHolders(name) {
-        if (!isNativeWebLocksAvailable()) {
-            return null;
-        }
-        const snapshot = (await safeAsync(() => navigator.locks.query()));
-        return (snapshot.held ?? []).filter((lock) => lock.name === name);
-    }
 
     const KEY_TOKEN = 'activity_token';
     const KEY_ACTIVITY_ID = 'activity_id';
@@ -198,7 +552,6 @@
                 this.startPromise = null;
             }
         }
-        // HAVE TO BE UNDER LOCK
         /**
          * @description Resolves the activity start by either loading from persistent storage or starting a new activity. **Have to be called under lock.**
          * @important **If start-activity api fails, system will try to recover by refresh path.**
@@ -291,18 +644,38 @@
      * @internal
      */
     const WIRE = {
-        schemaVersion: '0.1.0',
-        sdkVersion: '0.1.0',
+        /** Injected at build time from package.json `version` via @rollup/plugin-replace. */
+        sdkVersion: "0.1.1",
+        /** Injected at build time via @rollup/plugin-replace. Bump when the wire schema changes. */
+        schemaVersion: "0.1.0",
         sdkPlatform: 'web',
         ndjsonContentType: 'application/x-ndjson',
         jsonContentType: 'application/json',
         gzipEncoding: 'gzip'};
 
+    /**
+     * @module managers/transport/constants
+     *
+     * @description
+     * Hard limits for the retry queue. Not exposed through `TransportConfig` to
+     * preserve the zero-config contract; promote to config fields under a
+     * non-breaking minor if a host use case requires tuning.
+     *
+     * @internal
+     */
+    /** Maximum number of send attempts for a single batch before it is dropped. */
+    const MAX_RETRY_ATTEMPTS = 3;
+    /**
+     * Maximum number of failed batches the retry queue will hold simultaneously.
+     * When the queue is full and a new failure arrives the oldest entry is evicted
+     * (FIFO) to make room.
+     */
+    const MAX_RETRY_BATCHES = 5;
+
     /**
      * Frozen array of all defined priority levels, used to initialise and iterate
      * per-priority drop counters.
      */
-    const PRIORITY_VALUES = Object.freeze([20, 40, 60, 80, 100]);
     /**
      * Base priority lookup keyed by `TRIEvent['name']`. TypeScript enforces
      * exhaustiveness — adding a new name to the `TRIEvent` union without a
@@ -441,136 +814,337 @@
         return impl();
     }
 
-    // TODO - use environment variables for sdkVersion and schemaVersion
+    /**
+     * @module managers/transport/transport
+     *
+     * @description
+     * TransportManager — the single component responsible for buffering TRIEvents
+     * and shipping them to the ingest endpoint as NDJSON batches.
+     *
+     * ### Threading model
+     * JavaScript is single-threaded. All methods are synchronous except for the
+     * promise chains that stem from `context.ingest`. Those chains run as
+     * microtasks and can therefore interleave between setTimeout callbacks, but
+     * they cannot interleave with synchronous code. The absence of `flushInFlight`
+     * is intentional: fire-and-forget batches are desirable — a slow backend
+     * should not block new events from being sent. The 10 s HTTP timeout bounds
+     * the maximum number of concurrent in-flight requests to 2 per
+     * `effectiveIntervalMs` window (one main flush + one retry drain) before
+     * adaptive backoff collapses cadence further.
+     *
+     * ### Concurrency guarantees
+     * 1. The retry queue holds at most `MAX_RETRY_BATCHES` entries. Combined with
+     *    the single shared `retryDrainTimer`, at most one retry is in-flight at
+     *    any time alongside the scheduled main flush.
+     * 2. No event is double-shipped: the retry queue and the main queue operate on
+     *    disjoint event sets; the drain timer is idempotent.
+     * 3. `stop()` is fire-and-forget — the keepalive drain may not complete if the
+     *    browser tears the page down within milliseconds after the call.
+     *
+     * @internal
+     */
+    /**
+     * Buffers `TRIEvent` instances and ships them in batches to the ingest
+     * endpoint on a scheduled interval, at capacity, and on lifecycle events.
+     *
+     * The scheduler is edge-triggered: a timer is started on the first `push()`
+     * when none is running, and re-armed only when the queue still holds events
+     * after a flush. This means an idle SDK holds no live timer.
+     *
+     * Retryable batch failures are enqueued in a bounded FIFO retry queue
+     * (`MAX_RETRY_BATCHES = 5`). A single shared drain timer fires after
+     * `effectiveIntervalMs` and sends the head entry. Each batch is retried up to
+     * `MAX_RETRY_ATTEMPTS = 10` times; exhausted batches are dropped. Consecutive
+     * drain failures widen the interval (adaptive backoff); the first successful
+     * flush or drain snaps it back to the base.
+     */
     class TransportManager {
         constructor(config, context) {
             this.config = config;
             this.context = context;
             this.queue = [];
-            this.retryQueue = [];
             this.flushTimer = null;
-            this.retryFlushTimer = null;
-            this.flushInFlight = false;
-            this.destroyed = false;
+            this.retryQueue = [];
+            this.retryDrainTimer = null;
+            this.started = false;
+            this.online = true;
+            this.consecutiveFailures = 0;
             this.batchSequence = 0;
-            /**
-             * Per-priority-class drop counters reset on every `createBatch()` call
-             * (architecture §10.3). Counts both evicted-existing and dropped-incoming
-             * events so the backend can distinguish "user idle" from "we threw it away".
-             */
-            this.droppedEvents = {
-                20: 0,
-                40: 0,
-                60: 0,
-                80: 0,
-                100: 0
-            };
+            this.effectiveIntervalMs = config.flush.intervalMs;
         }
         /**
-         * Enqueues an event. If the queue has reached the flush batch size and no
-         * flush is in flight, a capacity flush is triggered immediately. If the
-         * queue is at hard cap, the priority-aware eviction algorithm runs before
-         * the event can be accepted (architecture §10.2).
+         * Enqueues an event. When the queue is at the normal flush batch size, a
+         * capacity flush fires immediately as a belt-and-braces guard for callers
+         * that configure a high `intervalMs`. If the hard queue cap is reached,
+         * priority-aware eviction runs before the event is accepted.
+         *
+         * No-ops silently when offline.
          */
         push(event) {
-            if (this.queue.length >= this.config.flush.size && !this.flushInFlight) {
-                void this.flush('capacity');
-                this.restartFlushTimer();
+            if (!this.started) {
+                logger.warn('Transport', 'push() called before start() — event dropped');
+                return;
             }
-            if (this.queue.length < this.config.queue.size) {
+            if (this.queue.length < this.effectiveQueueCap()) {
                 this.queue.push(event);
+            }
+            else {
+                this.evictAndPush(event);
+            }
+            if (!this.online)
+                return;
+            if (this.queue.length >= this.config.flush.size) {
+                safeClearTimeout(this.flushTimer);
+                this.flushTimer = null;
+                this.flush('capacity');
                 return;
             }
-            this.evictAndEnqueue(event);
+            this.scheduleFlush();
         }
-        async flush(reason) {
-            if (this.flushInFlight)
-                return;
-            if (this.queue.length === 0)
+        /**
+         * Synchronous, fire-and-forget flush. Splices a batch from the queue and
+         * starts an `ingest` promise chain without awaiting it. Any thrown or
+         * rejected error is contained — it never surfaces as an unhandled rejection.
+         *
+         * On the lifecycle path (`reason === 'lifecycle'`): drains both the retry
+         * queue (if non-empty) and the newest `flush.size` events from the main
+         * queue using keepalive mode.
+         */
+        flush(reason) {
+            if (!this.started)
                 return;
-            const batch = this.createBatch();
-            this.flushInFlight = true;
             try {
-                const keepalive = reason === 'lifecycle';
-                let result;
-                try {
-                    result = await this.context.ingest(batch, keepalive);
-                }
-                catch (error) {
-                    if (true) {
-                        // eslint-disable-next-line no-console
-                        console.warn('[TriSDK] ingest threw unexpectedly — batch dropped:', error);
-                    }
+                if (reason === 'lifecycle') {
+                    this.flushLifecycle();
                     return;
                 }
-                if (!result.ok && reason !== 'lifecycle' && this.isRetryable(result)) {
-                    this.retryQueue.push({ batch, attempt: 0 });
-                    this.scheduleRetryFlush();
+                if (this.queue.length === 0)
+                    return;
+                const batch = this.createBatch(reason);
+                void this.context
+                    .ingest(batch, false)
+                    .then((result) => this.handleIngestResult(result, batch))
+                    .catch(() => {
+                    logger.warn('Transport', 'ingest threw unexpectedly — batch dropped');
+                });
+                if (this.queue.length > 0) {
+                    this.scheduleFlush();
                 }
             }
-            finally {
-                this.flushInFlight = false;
+            catch (error) {
+                logger.warn('Transport', 'flush() threw unexpectedly:', error);
             }
         }
+        /**
+         * Starts the transport manager. Idempotent — a second call is a no-op.
+         * Seeds the online state from `navigator.onLine` at call time.
+         */
         start() {
-            this.scheduleFlush();
-        }
-        destroy() {
-            this.destroyed = true;
-            if (this.flushTimer !== null) {
-                clearTimeout(this.flushTimer);
-                this.flushTimer = null;
-            }
-            if (this.retryFlushTimer !== null) {
-                clearTimeout(this.retryFlushTimer);
-                this.retryFlushTimer = null;
-            }
-        }
-        scheduleFlush() {
-            if (this.destroyed)
+            if (this.started)
                 return;
-            this.flushTimer = setTimeout(async () => {
-                try {
-                    await this.flush('interval');
-                }
-                finally {
-                    this.scheduleFlush();
-                }
-            }, this.config.flush.intervalMs);
+            this.started = true;
+            this.online = typeof navigator !== 'undefined' ? navigator.onLine : true;
         }
-        restartFlushTimer() {
-            if (this.flushTimer !== null)
-                clearTimeout(this.flushTimer);
-            this.scheduleFlush();
+        /**
+         * Stops the transport manager. Cancels all timers and fires a best-effort
+         * keepalive drain of the retry queue and the newest `flush.size` events.
+         * Synchronous and void — the keepalive requests may not complete before the
+         * browser tears the page down.
+         */
+        stop() {
+            if (!this.started)
+                return;
+            safeClearTimeout(this.flushTimer);
+            this.flushTimer = null;
+            safeClearTimeout(this.retryDrainTimer);
+            this.retryDrainTimer = null;
+            this.flush('lifecycle');
+            this.started = false;
+        }
+        /**
+         * Notifies the manager that the browser's connection state has changed.
+         * Reads `navigator.onLine` inline at call time.
+         *
+         * On transition to offline: cancels both timers but preserves the retry
+         * queue so no pending retry batches are lost.
+         * On transition to online: schedules an immediate flush if the main queue is
+         * non-empty; re-arms the retry drain if the retry queue is non-empty.
+         */
+        onConnectionChange() {
+            const nowOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+            if (nowOnline === this.online)
+                return;
+            this.online = nowOnline;
+            if (!this.online) {
+                safeClearTimeout(this.flushTimer);
+                this.flushTimer = null;
+                safeClearTimeout(this.retryDrainTimer);
+                this.retryDrainTimer = null;
+                return;
+            }
+            if (this.queue.length > 0) {
+                this.scheduleFlush();
+            }
+            if (this.retryQueue.length > 0) {
+                this.scheduleRetryDrain();
+            }
         }
-        scheduleRetryFlush() {
-            if (this.destroyed)
+        /**
+         * Schedules a flush after `effectiveIntervalMs`. Idempotent — if a timer is
+         * already running the call is a no-op. No-ops if the manager is stopped or
+         * offline.
+         */
+        scheduleFlush() {
+            if (!this.started || !this.online || this.flushTimer !== null)
                 return;
-            if (this.retryFlushTimer !== null)
+            this.flushTimer = safeSetTimeout(() => {
+                this.flushTimer = null;
+                this.flush('interval');
+            }, this.effectiveIntervalMs);
+        }
+        /**
+         * Arms the shared retry drain timer for `effectiveIntervalMs`. Idempotent
+         * — if the drain timer is already running the call is a no-op. No-ops if
+         * the manager is stopped or offline.
+         */
+        scheduleRetryDrain() {
+            if (!this.started || !this.online || this.retryDrainTimer !== null)
                 return;
-            if (this.retryQueue.length === 0)
+            this.retryDrainTimer = safeSetTimeout(() => {
+                this.retryDrainTimer = null;
+                this.drainRetryQueue();
+            }, this.effectiveIntervalMs);
+        }
+        /**
+         * Dequeues the head entry from the retry queue and fires a single `ingest`
+         * call. If the queue still contains entries after the result is handled,
+         * `scheduleRetryDrain()` re-arms the timer, keeping the drain rate at one
+         * batch per `effectiveIntervalMs`.
+         */
+        drainRetryQueue() {
+            if (!this.started || !this.online || this.retryQueue.length === 0)
                 return;
-            this.retryFlushTimer = setTimeout(() => {
-                this.retryFlushTimer = null;
-                void this.flushRetryQueue();
-            }, this.config.flush.intervalMs * 2);
-        }
-        async flushRetryQueue() {
-            const due = this.retryQueue.splice(0, this.retryQueue.length);
-            for (const item of due) {
-                const result = await this.context.ingest(item.batch, false);
-                if (result.ok)
-                    continue;
-                if (!this.isRetryable(result) || item.attempt >= 1) {
-                    {
-                        // eslint-disable-next-line no-console
-                        console.warn('[TriSDK] batch dropped after retries:', item.batch.batchId);
-                    }
-                    continue;
-                }
-                this.retryQueue.push({ batch: item.batch, attempt: item.attempt + 1 });
+            const entry = this.retryQueue.shift();
+            void this.context
+                .ingest(entry.batch, false)
+                .then((result) => this.handleRetryResult(result, entry))
+                .catch(() => {
+                logger.warn('Transport', 'retry drain ingest threw unexpectedly — batch dropped');
+                if (this.retryQueue.length > 0)
+                    this.scheduleRetryDrain();
+            });
+        }
+        /**
+         * Enqueues a failed batch for retry. If the queue is at `MAX_RETRY_BATCHES`
+         * the oldest entry is evicted (FIFO) to make room, accepting the loss of
+         * that batch's events. Arms the drain timer if not already running.
+         */
+        enqueueRetry(batch, attempts) {
+            if (this.retryQueue.length >= MAX_RETRY_BATCHES) {
+                this.retryQueue.shift();
+                logger.warn('Transport', 'retry queue full — oldest batch evicted');
+            }
+            this.retryQueue.push({ batch, attempts });
+            this.scheduleRetryDrain();
+        }
+        /**
+         * Handles the resolved result of a main-flush `ingest` call.
+         *
+         * - Success: snap the backoff interval back to the configured base.
+         * - Retryable failure: hand the batch to the retry queue.
+         * - Non-retryable failure (`abort`, `client`, `parse`, `serialize`): accept
+         *   the loss — retrying would produce the same outcome.
+         */
+        handleIngestResult(result, batch) {
+            if (result.ok) {
+                this.resetBackoffOnSuccess();
+                return;
+            }
+            if (!this.isRetryable(result))
+                return;
+            this.enqueueRetry(batch, 1);
+        }
+        /**
+         * Handles the resolved result of a retry-drain `ingest` call.
+         *
+         * - Success: snap the backoff interval back to the configured base; re-arm
+         *   the drain if more entries remain.
+         * - Retryable + attempts under cap: increment `attempts`, push to the tail,
+         *   widen backoff if the failure threshold is crossed, re-arm drain.
+         * - Retryable + attempts exhausted: accept the loss, widen backoff, re-arm
+         *   drain if more entries remain.
+         * - Non-retryable: drop silently, re-arm drain if more entries remain.
+         */
+        handleRetryResult(result, entry) {
+            if (result.ok) {
+                this.resetBackoffOnSuccess();
+                if (this.retryQueue.length > 0)
+                    this.scheduleRetryDrain();
+                return;
+            }
+            if (!this.isRetryable(result)) {
+                if (this.retryQueue.length > 0)
+                    this.scheduleRetryDrain();
+                return;
+            }
+            if (entry.attempts >= MAX_RETRY_ATTEMPTS) {
+                this.adjustBackoffInterval();
+                logger.warn('Transport', 'batch dropped after MAX_RETRY_ATTEMPTS', entry.batch.batchId);
+                if (this.retryQueue.length > 0)
+                    this.scheduleRetryDrain();
+                return;
+            }
+            this.adjustBackoffInterval();
+            this.enqueueRetry(entry.batch, entry.attempts + 1);
+        }
+        /**
+         * Increments the consecutive-failure counter and doubles `effectiveIntervalMs`
+         * once the `backoffFailureThreshold` is crossed, up to `maxIntervalMs`.
+         */
+        adjustBackoffInterval() {
+            this.consecutiveFailures++;
+            if (this.consecutiveFailures % this.config.flush.backoffFailureThreshold ===
+                0) {
+                this.effectiveIntervalMs = Math.min(this.effectiveIntervalMs * 2, this.config.flush.maxIntervalMs);
+            }
+        }
+        /**
+         * Snaps both the consecutive-failure counter and `effectiveIntervalMs` back
+         * to their initial values on the first successful flush or drain.
+         */
+        resetBackoffOnSuccess() {
+            this.consecutiveFailures = 0;
+            this.effectiveIntervalMs = this.config.flush.intervalMs;
+        }
+        /**
+         * Returns the current effective queue hard cap. The cap doubles when the
+         * browser is offline so that events are preserved longer during outages.
+         */
+        effectiveQueueCap() {
+            return this.config.queue.size * (this.online ? 1 : 2);
+        }
+        /**
+         * Drains all retry queue entries as best-effort keepalive requests (in
+         * FIFO order) then sends the newest `flush.size` events from the main queue
+         * as a keepalive.
+         *
+         * NOTE: keepalive bodies are capped at ~64 KiB by browsers. Sending up to
+         * `MAX_RETRY_BATCHES + 1` keepalive requests in rapid succession may exceed
+         * per-request or aggregate browser limits. See proposal open question §3.
+         */
+        flushLifecycle() {
+            for (const entry of this.retryQueue) {
+                void this.context.ingest(entry.batch, true).catch(() => {
+                    logger.warn('Transport', 'lifecycle retry ingest threw — batch dropped');
+                });
             }
-            this.scheduleRetryFlush();
+            this.retryQueue = [];
+            if (this.queue.length === 0)
+                return;
+            const batch = this.createBatch('lifecycle');
+            void this.context.ingest(batch, true).catch(() => {
+                logger.warn('Transport', 'lifecycle ingest threw — batch dropped');
+            });
         }
         /**
          * Priority-aware eviction (architecture §10.2).
@@ -578,526 +1152,666 @@
          * Walks the queue oldest → newest to find the first event whose priority is
          * strictly less than the incoming event's priority. If found, evicts it and
          * enqueues the incoming event. If no lower-priority candidate exists, the
-         * incoming event is dropped instead.
-         *
-         * Both the evicted-existing case and the dropped-incoming case increment the
-         * `droppedEvents` counter for the affected priority class (§10.3): any loss
-         * must be reflected in the batch envelope so the backend can distinguish
-         * pressure-induced drops from genuine user inactivity.
+         * incoming event is dropped (it has the lowest priority in the queue).
          */
-        evictAndEnqueue(event) {
+        evictAndPush(event) {
             const incomingPriority = getEventPriority(event);
             for (let index = 0; index < this.queue.length; index++) {
                 const candidatePriority = getEventPriority(this.queue[index]);
                 if (candidatePriority < incomingPriority) {
-                    this.queue.splice(index, 1);
-                    this.droppedEvents[candidatePriority]++;
+                    for (let i = index; i < this.queue.length - 1; i++) {
+                        this.queue[i] = this.queue[i + 1];
+                    }
+                    this.queue.length -= 1;
                     this.queue.push(event);
                     return;
                 }
             }
-            // No evictable candidate found — the incoming event itself is dropped.
-            this.droppedEvents[incomingPriority]++;
         }
         /**
-         * Retry policy for the http layer's discriminated failure kinds.
+         * Assembles a batch from the queue.
+         *
+         * Normal path: splices `flush.size` events from the head (FIFO).
+         * Lifecycle path: splices `flush.size` events from the tail (newest-first).
+         *
+         * `activityId` is intentionally set to an empty string here. The authoritative
+         * value is stamped by the `api.ts` `withAuth` callback immediately before the
+         * network request, ensuring that a 401-triggered token refresh (which mints a
+         * new activityId on the backend) is reflected in the retried request.
+         */
+        createBatch(reason) {
+            const events = reason === 'lifecycle'
+                ? this.queue.splice(-this.config.flush.size)
+                : this.queue.splice(0, this.config.flush.size);
+            return {
+                activityId: '',
+                batchId: generateUUID(),
+                batchSequence: this.batchSequence++,
+                clientTimestamp: Date.now(),
+                schemaVersion: WIRE.schemaVersion,
+                sdkVersion: WIRE.sdkVersion,
+                sdkPlatform: WIRE.sdkPlatform,
+                tabId: this.context.getTabId(),
+                events
+            };
+        }
+        /**
+         * Returns whether a failed `HttpResult` is worth retrying.
          *
-         * - `network` / `timeout`: transient transport issue, retry.
-         * - `server` / `rate_limited`: backend asked us to back off, retry.
-         * - `abort`: the request was cancelled deliberately (today only via
-         *   `options.signal` from teardown paths). Retrying defeats the cancel.
+         * - `network` / `timeout`: transient transport issue.
+         * - `server` / `rate_limited`: backend asked us to back off.
+         * - `abort`: deliberate cancellation; retrying defeats the cancel.
          * - `client` / `parse` / `serialize`: our bug; the next attempt will
-         *   fail the same way. Drop the batch.
+         *   produce the same result. Drop the batch.
+         *
+         * NOTE: If a new kind is added to `HttpResult['kind']` in `@/lib/http/types`,
+         * update this switch. See the JSDoc on that type for the full extension guide.
          */
         isRetryable(result) {
             if (result.ok)
                 return false;
             switch (result.kind) {
-                case 'network':
                 case 'timeout':
                 case 'server':
                 case 'rate_limited':
                     return true;
-                default:
+                case 'abort':
+                case 'client':
+                case 'parse':
+                case 'serialize':
+                case 'network':
                     return false;
+                default: {
+                    return false;
+                }
             }
         }
-        createBatch() {
-            const droppedEvents = this.snapshotAndResetDroppedEvents();
-            return {
-                activityId: this.context.getActivityId(),
-                batchId: generateUUID(),
-                batchSequence: this.batchSequence++,
-                clientTimestamp: Date.now(),
-                schemaVersion: WIRE.schemaVersion,
-                sdkVersion: WIRE.sdkVersion,
-                sdkPlatform: WIRE.sdkPlatform,
-                tabId: this.context.getTabId(),
-                droppedEvents,
-                events: this.queue.splice(0, this.config.flush.size)
-            };
+    }
+
+    function createStorage(storageId) {
+        function hasStorage() {
+            return (globalThis.window &&
+                globalThis.window[storageId] &&
+                typeof globalThis.window[storageId] !== 'undefined');
         }
-        /**
-         * Snapshots the current per-priority drop counters as a `Record<string,
-         * number>` (string keys are stable JSON) and resets the in-memory counters
-         * to zero in the same step. Called exactly once per `createBatch()`.
-         */
-        snapshotAndResetDroppedEvents() {
-            const snapshot = {};
-            for (const priority of PRIORITY_VALUES) {
-                snapshot[String(priority)] = this.droppedEvents[priority];
-                this.droppedEvents[priority] = 0;
+        function get(key) {
+            if (!hasStorage())
+                return null;
+            try {
+                const raw = window[storageId].getItem(key) ?? 'null';
+                if (raw === 'null')
+                    return null;
+                return JSON.parse(raw);
             }
-            return snapshot;
+            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');
 
-    /** Maximum byte length of a URL stored in any NetworkRequest event field. */
-    const MAX_URL_LENGTH = 2048;
-    /**
-     * Initiator types the PerformanceObserver entry mapper normalises to 'other'
-     * when the browser returns a string not in the known enumeration.
-     */
-    const KNOWN_INITIATOR_TYPES = new Set([
-        'xmlhttprequest',
-        'fetch',
-        'beacon',
-        'navigation',
-        'script',
-        'link',
-        'css',
-        'img',
-        'iframe',
-        'video',
-        'audio'
-    ]);
     /**
-     * Default set of PerformanceResourceTiming initiator types that the observer
-     * emits events for. Restricted to API-call sources by default to avoid
-     * generating high-volume events for every image, script, and stylesheet load.
+     * @module storage-event-channel
      *
-     * Callers can override this by passing a custom set to `createResourceObserver`.
-     * Pass `KNOWN_INITIATOR_TYPES` (or a superset) to capture all resource types.
-     */
-    const DEFAULT_RESOURCE_INITIATOR_TYPES = new Set([
-        'xmlhttprequest',
-        'fetch',
-        'beacon'
-    ]);
-    /** Name used in error logging for this collector. */
-    const COLLECTOR_NAME = 'network-request';
-
-    /**
-     * Clamps a URL string to MAX_URL_LENGTH characters so enormous query strings
-     * do not bloat the wire payload.
-     */
-    function truncateUrl(url) {
-        return url.length > MAX_URL_LENGTH ? url.slice(0, MAX_URL_LENGTH) : url;
-    }
-    /**
-     * Normalises the raw string from PerformanceResourceTiming.initiatorType into
-     * the known enumeration, falling back to 'other' for unrecognised values.
-     */
-    function normaliseInitiatorType(raw) {
-        return KNOWN_INITIATOR_TYPES.has(raw)
-            ? raw
-            : 'other';
-    }
-    /**
-     * Returns null when the entry's value is 0 and the field is a phase timing
-     * that is expected to be null cross-origin (the browser sets it to 0 in that
-     * case, not to a meaningful zero-duration).
+     * BroadcastChannel fallback backed by localStorage + the window `storage` event.
+     *
+     * ## How it works
+     *
+     * `postMessage` serialises the payload to JSON and writes it under a unique
+     * key (`tri:bcast:<channel>:<sender-uuid>:<seq>`). The `storage` event fires
+     * synchronously in every other tab that has the same origin. The writer then
+     * immediately removes the key so no durable state is left in localStorage.
+     *
+     * ## Same-tab echo prevention
+     *
+     * The browser's `storage` event does NOT fire in the tab that performed the
+     * write — this matches native BroadcastChannel's contract exactly. The
+     * listener in this file therefore never echoes a message back to the sender.
+     * Do NOT change the mechanism (e.g. dispatch a synthetic StorageEvent) without
+     * verifying this invariant is preserved.
+     *
+     * ## Key lifecycle
+     *
+     * 1. Writer: setItem → removeItem (synchronous, back-to-back).
+     * 2. Receiver: sees the storage event for setItem (newValue = payload), parses
+     *    it, then defensively calls removeItem on the key to clean up any entry
+     *    that survived a writer crash. Events for removeItem (newValue = null) are
+     *    ignored.
+     *
+     * ## Failure isolation
      *
-     * The heuristic: when responseStart === 0 the browser withheld the timing
-     * information due to the Timing-Allow-Origin policy.
+     * Throws inside JSON.parse, listener callbacks, or localStorage writes are
+     * caught and silently dropped. The channel degrades to a no-op per operation
+     * rather than crashing the host page (rule #2 of CLAUDE.md).
      */
-    function phaseMs(value, hasTimingAccess) {
-        return hasTimingAccess ? value : null;
-    }
+    const STORAGE_KEY_PREFIX = 'tri:bcast:';
     /**
-     * Maps a PerformanceResourceTiming entry to a NetworkRequestResourceEvent
-     * ready to push into the collector context.
+     * BroadcastChannel-like backed by localStorage and the window `storage` event.
+     * Used as a fallback on browsers that do not support native BroadcastChannel.
      */
-    function toResourceEvent(entry) {
-        const now = performance.now();
-        // responseStart === 0 (and duration > 0) is the browser's signal that
-        // cross-origin Timing-Allow-Origin headers were absent.
-        const hasTimingAccess = entry.responseStart > 0;
-        const dnsLookupMs = phaseMs(entry.domainLookupEnd - entry.domainLookupStart, hasTimingAccess);
-        const tcpConnectMs = phaseMs(entry.connectEnd - entry.connectStart, hasTimingAccess);
-        const tlsHandshakeMs = phaseMs(entry.connectEnd > 0 && entry.secureConnectionStart > 0
-            ? entry.connectEnd - entry.secureConnectionStart
-            : 0, hasTimingAccess);
-        const ttfbMs = phaseMs(entry.responseStart - entry.requestStart, hasTimingAccess);
-        const responseDownloadMs = phaseMs(entry.responseEnd - entry.responseStart, hasTimingAccess);
-        const transferSize = hasTimingAccess ? entry.transferSize : null;
-        const encodedBodySize = hasTimingAccess ? entry.encodedBodySize : null;
-        const decodedBodySize = hasTimingAccess ? entry.decodedBodySize : null;
-        const nextHopProtocol = hasTimingAccess ? entry.nextHopProtocol || null : null;
-        // deliveryType is a newer addition; safely access via optional chaining.
-        const deliveryTypeRaw = entry.deliveryType;
-        const deliveryType = hasTimingAccess && deliveryTypeRaw !== undefined
-            ? deliveryTypeRaw
-            : null;
-        // responseStatus is Chrome 112+. Safely access via optional chaining.
-        const responseStatusRaw = entry.responseStatus;
-        const responseStatus = responseStatusRaw !== undefined ? responseStatusRaw : null;
-        return {
-            name: 'network_request',
-            type: 'resource',
-            timestamp: Date.now(),
-            performanceTime: now,
-            url: truncateUrl(entry.name),
-            initiatorType: normaliseInitiatorType(entry.initiatorType),
-            startTime: entry.startTime,
-            durationMs: entry.duration,
-            dnsLookupMs,
-            tcpConnectMs,
-            tlsHandshakeMs,
-            ttfbMs,
-            responseDownloadMs,
-            transferSize,
-            encodedBodySize,
-            decodedBodySize,
-            nextHopProtocol,
-            deliveryType,
-            responseStatus
-        };
-    }
-    /**
-     * Derives the byte count of a fetch / XHR request body without consuming
-     * it. Returns null for body types where consumption would be required
-     * (FormData, URLSearchParams, ReadableStream) or when the body is absent.
-     */
-    function deriveRequestBodyBytes(body) {
-        if (body === null || body === undefined)
-            return null;
-        if (typeof body === 'string')
-            return new TextEncoder().encode(body).byteLength;
-        if (body instanceof ArrayBuffer)
-            return body.byteLength;
-        if (ArrayBuffer.isView(body))
-            return body.byteLength;
-        if (body instanceof Blob)
-            return body.size;
-        // FormData, URLSearchParams, ReadableStream: cannot measure without consuming.
-        return null;
+    class StorageEventChannel {
+        constructor(name) {
+            this.seq = 0;
+            this.closed = false;
+            this.listeners = new Set();
+            /**
+             * Arrow property so `this` is bound when passed directly to
+             * addEventListener / removeEventListener.
+             */
+            this.onStorageEvent = (event) => {
+                if (this.closed)
+                    return;
+                const keyPrefix = `${STORAGE_KEY_PREFIX}${this.channelName}:`;
+                if (!event.key || !event.key.startsWith(keyPrefix))
+                    return;
+                // Ignore the removal event produced by the writer's own removeItem call.
+                if (event.newValue === null)
+                    return;
+                // Defensive cleanup: the writer should have removed this already, but
+                // guard against crashes mid-write that leave a stale entry.
+                safeSync(() => LocalStorage.remove(event.key));
+                let data;
+                try {
+                    data = JSON.parse(event.newValue);
+                }
+                catch {
+                    return;
+                }
+                const dispatched = { data };
+                for (const listener of this.listeners) {
+                    safeSync(() => listener(dispatched));
+                }
+            };
+            this.channelName = name;
+            this.senderId = generateUUID();
+            window.addEventListener('storage', this.onStorageEvent);
+        }
+        /**
+         * Serialises `message` to JSON, writes it under a unique key, then removes
+         * it immediately. The write triggers the `storage` event in all other tabs
+         * on the same origin; the removal keeps localStorage clean.
+         *
+         * Payload size is not explicitly bounded here because tab-discovery messages
+         * are tiny plain-object JSON. If the channel is ever used for larger payloads
+         * this assumption must be revisited against the ~5 MB localStorage quota.
+         */
+        postMessage(message) {
+            if (this.closed)
+                return;
+            const key = `${STORAGE_KEY_PREFIX}${this.channelName}:${this.senderId}:${this.seq++}`;
+            safeSync(() => {
+                LocalStorage.set(key, message);
+                // The storage event fires in other tabs upon setItem; remove the key
+                // immediately so no stale entry persists if a subsequent read races.
+                LocalStorage.remove(key);
+            });
+        }
+        addEventListener(_type, listener) {
+            this.listeners.add(listener);
+        }
+        removeEventListener(_type, listener) {
+            this.listeners.delete(listener);
+        }
+        /** Detaches the storage listener and prevents further dispatch. */
+        close() {
+            if (this.closed)
+                return;
+            this.closed = true;
+            window.removeEventListener('storage', this.onStorageEvent);
+            this.listeners.clear();
+        }
     }
+
     /**
-     * Resolves the URL string from a fetch RequestInfo argument, which may be
-     * a plain string, a URL object, or a Request object.
+     * @module broadcast-channel
+     *
+     * Ponyfill selector for BroadcastChannel.
+     *
+     * ## Ponyfill, not polyfill
+     *
+     * This module exports `TriBroadcastChannel` — a local binding that resolves
+     * to native BroadcastChannel when available, a localStorage fallback when not,
+     * or a no-op when neither storage mechanism is usable (e.g. private mode with
+     * storage blocked). The host page's `globalThis` is never modified.
+     *
+     * ## Detection order
+     *
+     * 1. Native `BroadcastChannel` — detected via `typeof BroadcastChannel === 'function'`
+     *    so any polyfill the host app installed is transparently honoured.
+     * 2. `StorageEventChannel` — requires `window` and a writable `localStorage`.
+     *    Availability is probed once at module load via a setItem/getItem/removeItem
+     *    round-trip, matching the approach used in `lib/immortal-db/storages/web.ts`.
+     * 3. `NoopChannel` — silent fallback when neither option is available. Emits
+     *    a `logger.warn` at construction time so developers can see that tab
+     *    discovery is disabled (when `DEBUG` is enabled).
+     *
+     * ## Module-load detection
+     *
+     * Selection happens once when this module is first imported and the result is
+     * cached in `TriBroadcastChannel`. This is intentional: re-probing on every
+     * constructor call would be wasteful and storage availability does not change
+     * within a session.
      */
-    function resolveRequestUrl(input) {
-        if (typeof input === 'string')
-            return input;
-        if (input instanceof URL)
-            return input.href;
-        // Request object
-        return input.url;
-    }
+    // ─── No-op channel ────────────────────────────────────────────────────────────
     /**
-     * Resolves the HTTP method from a fetch RequestInfo argument, with an
-     * optional override from RequestInit.method.
+     * Silent fallback used when neither native BroadcastChannel nor localStorage
+     * is available. All operations are no-ops. Tab count will stay at 1.
+     * Emits a `logger.warn` at construction so developers can see that
+     * cross-tab discovery is disabled (when `DEBUG` is enabled).
      */
-    function resolveRequestMethod(input, init) {
-        if (init?.method)
-            return init.method.toUpperCase();
-        if (input instanceof Request)
-            return input.method.toUpperCase();
-        return 'GET';
+    class NoopChannel {
+        constructor(_name) {
+            logger.warn('BroadcastChannel', 'BroadcastChannel is unavailable and localStorage is not ' +
+                'writable in this context. Cross-tab discovery is disabled; tab ' +
+                'count will always be reported as 1.');
+        }
+        postMessage(_message) { }
+        addEventListener(_type, _listener) { }
+        removeEventListener(_type, _listener) { }
+        close() { }
     }
+    // ─── Availability probes ──────────────────────────────────────────────────────
     /**
-     * Returns true when the given URL shares the same origin as the current page.
-     * Silently returns false for URLs that cannot be parsed.
+     * Returns true if `localStorage` is present and can be written to.
+     * Catches: Safari private mode (throws on setItem), storage disabled by
+     * policy, quota-exhausted state.
+     *
+     * Uses `typeof Storage !== 'undefined'` as a fast pre-check; the round-trip
+     * write is needed because that check alone is unreliable in embedded contexts.
      */
-    function isSameOrigin(url) {
+    function isLocalStorageWritable() {
+        if (typeof Storage === 'undefined' || typeof window === 'undefined') {
+            return false;
+        }
         try {
-            return new URL(url, location.href).origin === location.origin;
+            const probeKey = '__tri_bcast_probe__';
+            localStorage.setItem(probeKey, '1');
+            const ok = localStorage.getItem(probeKey) === '1';
+            localStorage.removeItem(probeKey);
+            return ok;
         }
         catch {
             return false;
         }
     }
+    // ─── Selector ─────────────────────────────────────────────────────────────────
+    function pickChannel() {
+        if (typeof BroadcastChannel === 'function') {
+            return BroadcastChannel;
+        }
+        if (isLocalStorageWritable()) {
+            return StorageEventChannel;
+        }
+        return NoopChannel;
+    }
+    /**
+     * Drop-in BroadcastChannel constructor that works across environments.
+     *
+     * Resolves at module load to:
+     * - Native `BroadcastChannel` when available (including host-app polyfills).
+     * - `StorageEventChannel` (localStorage + storage event) on older browsers.
+     * - `NoopChannel` when neither is usable.
+     *
+     * Usage is identical to native BroadcastChannel:
+     * ```ts
+     * const channel = new TriBroadcastChannel('my-channel')
+     * channel.addEventListener('message', handler)
+     * channel.postMessage({ type: 'hello' })
+     * channel.close()
+     * ```
+     */
+    const TriBroadcastChannel = pickChannel();
 
-    function installFetchPatch(emit, shouldIgnore) {
-        // Capture whatever fetch is installed right now. If a third-party
-        // instrumentation (Sentry, Datadog) wrapped fetch before us, we preserve
-        // their wrapper as our "previous" reference and call it from our patch.
-        const previousFetch = typeof globalThis.fetch === 'function' ? globalThis.fetch : undefined;
-        if (previousFetch === undefined) {
-            return () => void 0;
-        }
-        const patchedFetch = function patchedFetchImpl(input, init) {
-            const url = resolveRequestUrl(input);
-            const truncatedUrl = truncateUrl(url);
-            const requestStart = performance.now();
-            if (shouldIgnore(url)) {
-                return previousFetch(input, init);
-            }
-            const method = resolveRequestMethod(input, init);
-            const credentials = init?.credentials ??
-                (input instanceof Request ? input.credentials : null);
-            const cache = init?.cache ?? (input instanceof Request ? input.cache : null);
-            const mode = init?.mode ?? (input instanceof Request ? input.mode : null);
-            const keepalive = init?.keepalive ?? false;
-            const requestBodyBytes = deriveRequestBodyBytes(init?.body ?? null);
-            let originalPromise;
+    const STORAGE_KEY$1 = 'tri:tabId';
+    const CHANNEL_NAME = 'tri:tab_channel';
+    const HEARTBEAT_INTERVAL_MS = 1000;
+    const IDLE_HEARTBEAT_INTERVAL_MS = 3 * HEARTBEAT_INTERVAL_MS;
+    /* setting to 1s due to browser tab throttling to 1Hz so 500ms could be missed */
+    const COUNT_EMIT_DEBOUNCE_MS = 1000;
+    class TabManager {
+        constructor(context) {
+            this.context = context;
+            this.tabId = '';
+            this.started = false;
+            this.broadcastChannel = null;
+            this.heartbeatTimer = null;
+            this.countEmitTimer = null;
+            this.peers = new Map();
+            this.lastEmittedCount = -1;
+            this.bound_OnBroadcastMessage = null;
+        }
+        async start() {
+            if (this.started)
+                return;
+            this.started = true;
+            this.tabId = this._generateTabId();
+            this._openChannel();
+            this._broadcast({ type: 'hello', tabId: this.tabId, ts: Date.now() });
+            this._startHeartbeat();
+            this._emitTabState('active');
+            this._scheduleCountEmit();
+        }
+        stop() {
+            if (!this.started)
+                return;
+            this.started = false;
+            this._emitTabState('inactive');
+            this._broadcast({ type: 'bye', tabId: this.tabId, ts: Date.now() });
+            /* there is no increment because we are emitting count of the remaining tabs */
+            this._emitTabCount(this._sweepPeers());
+            this._stopHeartbeat();
+            this._cancelCountEmit();
+            this._closeChannel();
+        }
+        getTabId() {
+            return this.tabId;
+        }
+        queryTabsNumber() {
+            return this.peers.size + 1;
+        }
+        _openChannel() {
             try {
-                originalPromise = previousFetch(input, init);
+                this.broadcastChannel = new TriBroadcastChannel(CHANNEL_NAME);
+                this.bound_OnBroadcastMessage = this._onBroadcastMessage.bind(this);
+                this.broadcastChannel.addEventListener('message', this.bound_OnBroadcastMessage);
             }
             catch (error) {
-                safeSync(() => {
-                    const requestEnd = performance.now();
-                    const event = {
-                        name: 'network_request',
-                        type: 'invocation',
-                        source: 'fetch',
-                        timestamp: Date.now(),
-                        performanceTime: requestEnd,
-                        url: truncatedUrl,
-                        method,
-                        isSameOrigin: isSameOrigin(url),
-                        credentials: credentials,
-                        cache,
-                        mode,
-                        keepalive,
-                        requestBodyBytes,
-                        requestStart,
-                        requestEnd,
-                        durationMs: requestEnd - requestStart,
-                        responseStatus: null,
-                        ok: null,
-                        outcome: 'error',
-                        errorName: error instanceof Error ? error.name.slice(0, 100) : 'UnknownError'
-                    };
-                    emit(event);
-                });
-                throw error;
-            }
-            // Side-effect observation branch. The returned promise from this .then()
-            // is intentionally discarded — the host receives `originalPromise`. Both
-            // handlers are provided so the floating branch can never become an
-            // unhandledrejection, and safeSync guarantees neither handler throws.
-            originalPromise.then((response) => {
-                safeSync(() => {
-                    const requestEnd = performance.now();
-                    const event = {
-                        name: 'network_request',
-                        type: 'invocation',
-                        source: 'fetch',
-                        timestamp: Date.now(),
-                        performanceTime: requestEnd,
-                        url: truncatedUrl,
-                        method,
-                        isSameOrigin: isSameOrigin(url),
-                        credentials: credentials,
-                        cache,
-                        mode,
-                        keepalive,
-                        requestBodyBytes,
-                        requestStart,
-                        requestEnd,
-                        durationMs: requestEnd - requestStart,
-                        responseStatus: response.status,
-                        ok: response.ok,
-                        outcome: response.ok ? 'success' : 'error',
-                        errorName: null
-                    };
-                    emit(event);
-                });
-            }, (error) => {
-                safeSync(() => {
-                    const requestEnd = performance.now();
-                    const isDomException = error instanceof DOMException;
-                    const outcome = isDomException && error.name === 'AbortError' ? 'abort' : 'error';
-                    const event = {
-                        name: 'network_request',
-                        type: 'invocation',
-                        source: 'fetch',
-                        timestamp: Date.now(),
-                        performanceTime: requestEnd,
-                        url: truncatedUrl,
-                        method,
-                        isSameOrigin: isSameOrigin(url),
-                        credentials: credentials,
-                        cache,
-                        mode,
-                        keepalive,
-                        requestBodyBytes,
-                        requestStart,
-                        requestEnd,
-                        durationMs: requestEnd - requestStart,
-                        responseStatus: null,
-                        ok: null,
-                        outcome,
-                        errorName: error instanceof Error ? error.name.slice(0, 100) : null
-                    };
-                    emit(event);
-                });
-            });
-            return originalPromise;
-        };
-        globalThis.fetch = patchedFetch;
-        return function disposeFetchPatch() {
-            if (globalThis.fetch === patchedFetch) {
-                globalThis.fetch = previousFetch;
+                logger.warn('TabManager', 'failed to open broadcast channel:', error);
             }
-        };
-    }
-
-    const requestStateMap = new WeakMap();
-    function installXhrPatch(emit, shouldIgnore) {
-        const OriginalXHR = typeof globalThis.XMLHttpRequest === 'function'
-            ? globalThis.XMLHttpRequest
-            : undefined;
-        const originalOpen = OriginalXHR?.prototype.open;
-        const originalSend = OriginalXHR?.prototype.send;
-        if (OriginalXHR === undefined ||
-            originalOpen === undefined ||
-            originalSend === undefined) {
-            return () => void 0;
-        }
-        const patchedOpen = function patchedXhrOpen(...args) {
-            const method = typeof args[0] === 'string' ? args[0] : String(args[0]);
-            const urlArg = args[1];
-            const resolvedUrl = urlArg instanceof URL ? urlArg.href : String(urlArg);
-            // A second open() on the same XHR resets the request — drop any stale
-            // state so we don't mis-attribute a later send() to the previous URL.
-            requestStateMap.set(this, {
-                method: method.toUpperCase(),
-                url: resolvedUrl,
-                requestStart: 0,
-                requestBodyBytes: null
-            });
-            // Forward exactly what the host passed, preserving argument count.
-            return originalOpen.apply(this, args);
-        };
-        const patchedSend = function patchedXhrSend(body) {
-            const state = requestStateMap.get(this);
-            if (state && !shouldIgnore(state.url)) {
-                state.requestStart = performance.now();
-                // XHR.send() accepts Document | XMLHttpRequestBodyInit | null.
-                // Document is not a BodyInit; guard with a feature check so this module
-                // remains safe in environments where Document is not a bare global.
-                const isDocument = typeof globalThis.Document !== 'undefined' && body instanceof globalThis.Document;
-                state.requestBodyBytes = deriveRequestBodyBytes(isDocument ? null : body);
-                const truncatedUrl = truncateUrl(state.url);
-                const cleanup = () => {
-                    this.removeEventListener('loadend', onLoadEnd);
-                    this.removeEventListener('timeout', onTimeout);
-                    this.removeEventListener('abort', onAbort);
-                };
-                const emitOutcome = (outcome) => {
-                    safeSync(() => {
-                        const requestEnd = performance.now();
-                        const status = this.status;
-                        const responseStatus = outcome === 'success' || outcome === 'error'
-                            ? (status > 0 ? status : null)
-                            : null;
-                        const ok = outcome === 'success'
-                            ? true
-                            : outcome === 'error' && responseStatus !== null
-                                ? false
-                                : null;
-                        const event = {
-                            name: 'network_request',
-                            type: 'invocation',
-                            source: 'xhr',
-                            timestamp: Date.now(),
-                            performanceTime: requestEnd,
-                            url: truncatedUrl,
-                            method: state.method,
-                            isSameOrigin: isSameOrigin(state.url),
-                            credentials: this.withCredentials ? 'include' : 'same-origin',
-                            cache: null,
-                            mode: null,
-                            keepalive: false,
-                            requestBodyBytes: state.requestBodyBytes,
-                            requestStart: state.requestStart,
-                            requestEnd,
-                            durationMs: requestEnd - state.requestStart,
-                            responseStatus,
-                            ok,
-                            outcome,
-                            errorName: null
-                        };
-                        emit(event);
-                        requestStateMap.delete(this);
-                    });
-                };
-                // Order of XHR terminal events per spec: abort/timeout fire BEFORE
-                // loadend. We attach all three and let whichever fires first own the
-                // outcome; cleanup removes the others so loadend doesn't double-emit.
-                let resolved = false;
-                const onAbort = () => {
-                    if (resolved)
-                        return;
-                    resolved = true;
-                    emitOutcome('abort');
-                    cleanup();
-                };
-                const onTimeout = () => {
-                    if (resolved)
-                        return;
-                    resolved = true;
-                    emitOutcome('timeout');
-                    cleanup();
-                };
-                const onLoadEnd = () => {
-                    if (resolved)
-                        return;
-                    resolved = true;
-                    const status = this.status;
-                    const isSuccess = status >= 200 && status < 400;
-                    emitOutcome(status > 0 ? (isSuccess ? 'success' : 'error') : 'error');
-                    cleanup();
-                };
-                this.addEventListener('abort', onAbort);
-                this.addEventListener('timeout', onTimeout);
-                this.addEventListener('loadend', onLoadEnd);
+        }
+        _closeChannel() {
+            try {
+                if (!this.broadcastChannel)
+                    return;
+                if (this.bound_OnBroadcastMessage) {
+                    this.broadcastChannel.removeEventListener('message', this.bound_OnBroadcastMessage);
+                }
+                this.broadcastChannel.close();
             }
-            return originalSend.call(this, body);
-        };
-        XMLHttpRequest.prototype.open = patchedOpen;
-        XMLHttpRequest.prototype.send = patchedSend;
-        return function disposeXhrPatch() {
-            if (XMLHttpRequest.prototype.open === patchedOpen) {
-                XMLHttpRequest.prototype.open = originalOpen;
+            catch {
+                // do nothing
             }
-            if (XMLHttpRequest.prototype.send === patchedSend) {
-                XMLHttpRequest.prototype.send = originalSend;
+            finally {
+                this.broadcastChannel = null;
+                this.bound_OnBroadcastMessage = null;
             }
-        };
-    }
-
-    function createResourceObserver(emit, shouldIgnore, allowedInitiatorTypes = DEFAULT_RESOURCE_INITIATOR_TYPES) {
-        if (typeof PerformanceObserver === 'undefined') {
-            return () => void 0;
         }
-        let observer = null;
-        try {
-            observer = new PerformanceObserver((list) => {
-                for (const entry of list.getEntries()) {
-                    safeSync(() => {
-                        if (entry.entryType !== 'resource')
-                            return;
-                        const resourceEntry = entry;
-                        if (!allowedInitiatorTypes.has(resourceEntry.initiatorType))
-                            return;
-                        if (shouldIgnore(resourceEntry.name))
-                            return;
-                        emit(toResourceEvent(resourceEntry));
-                    });
-                }
+        _startHeartbeat() {
+            this.heartbeatTimer = setInterval(() => {
+                const now = Date.now();
+                this._broadcast({
+                    type: 'heartbeat',
+                    tabId: this.tabId,
+                    ts: now
+                });
+            }, HEARTBEAT_INTERVAL_MS);
+        }
+        _stopHeartbeat() {
+            if (this.heartbeatTimer != null) {
+                clearInterval(this.heartbeatTimer);
+                this.heartbeatTimer = null;
+            }
+        }
+        _scheduleCountEmit() {
+            if (this.countEmitTimer != null)
+                clearTimeout(this.countEmitTimer);
+            this.countEmitTimer = setTimeout(() => {
+                this.countEmitTimer = null;
+                const count = this._sweepPeers() + 1;
+                if (count === this.lastEmittedCount)
+                    return;
+                this.lastEmittedCount = count;
+                this._emitTabCount(count);
+            }, COUNT_EMIT_DEBOUNCE_MS);
+        }
+        _cancelCountEmit() {
+            if (this.countEmitTimer != null) {
+                clearTimeout(this.countEmitTimer);
+                this.countEmitTimer = null;
+            }
+        }
+        _broadcast(message) {
+            try {
+                if (!this.broadcastChannel)
+                    return;
+                this.broadcastChannel.postMessage(message);
+            }
+            catch {
+                logger.warn('TabManager', 'failed to broadcast message:', message);
+            }
+        }
+        _onBroadcastMessage(event) {
+            const { type, tabId } = event.data;
+            if (tabId === this.tabId)
+                return;
+            const receivedAt = Date.now();
+            if (type === 'hello') {
+                this._broadcast({
+                    type: 'ack',
+                    tabId: this.tabId,
+                    ts: receivedAt,
+                    to: tabId
+                });
+                this.peers.set(tabId, receivedAt);
+            }
+            else if (type === 'heartbeat') {
+                this.peers.set(tabId, receivedAt);
+            }
+            else if (type === 'ack') {
+                this.peers.set(tabId, receivedAt);
+            }
+            else if (type === 'bye') {
+                this.peers.delete(tabId);
+            }
+        }
+        _emitTabCount(value) {
+            this.context.push({
+                name: 'tab',
+                type: 'count',
+                tabId: this.tabId,
+                timestamp: Date.now(),
+                value
+            });
+        }
+        _emitTabState(value) {
+            this.context.push({
+                name: 'tab',
+                type: 'state',
+                tabId: this.tabId,
+                timestamp: Date.now(),
+                value
+            });
+        }
+        _generateTabId() {
+            const existing = SessionStorage.get(STORAGE_KEY$1);
+            if (existing)
+                return existing;
+            const fresh = generateUUID();
+            SessionStorage.set(STORAGE_KEY$1, fresh);
+            return fresh;
+        }
+        _sweepPeers(now = Date.now()) {
+            let active = 0;
+            for (const [tabId, timestamp] of this.peers.entries()) {
+                if (now - timestamp >= IDLE_HEARTBEAT_INTERVAL_MS) {
+                    this.peers.delete(tabId);
+                }
+                else {
+                    active++;
+                }
+            }
+            return active;
+        }
+    }
+
+    /** Maximum UTF-16 code-unit length of a URL stored in any NetworkRequest event field. */
+    const MAX_URL_LENGTH = 2048;
+    /**
+     * Initiator types the PerformanceObserver entry mapper normalises to 'other'
+     * when the browser returns a string not in the known enumeration.
+     */
+    const KNOWN_INITIATOR_TYPES = new Set([
+        'xmlhttprequest',
+        'fetch',
+        'beacon',
+        'navigation',
+        'script',
+        'link',
+        'css',
+        'img',
+        'iframe',
+        'video',
+        'audio'
+    ]);
+    /**
+     * Default set of PerformanceResourceTiming initiator types that the observer
+     * emits events for. Restricted to API-call sources by default to avoid
+     * generating high-volume events for every image, script, and stylesheet load.
+     *
+     * Callers can override this by passing a custom set to `createResourceObserver`.
+     * Pass `KNOWN_INITIATOR_TYPES` (or a superset) to capture all resource types.
+     */
+    const DEFAULT_RESOURCE_INITIATOR_TYPES = new Set([
+        'xmlhttprequest',
+        'fetch',
+        'beacon'
+    ]);
+    /** Name used in error logging for this collector. */
+    const COLLECTOR_NAME = 'network-request';
+
+    /**
+     * Normalises the raw string from PerformanceResourceTiming.initiatorType into
+     * the known enumeration, falling back to 'other' for unrecognised values.
+     * Note: in the default config, allowedInitiatorTypes restricts entries to
+     * fetch, XHR, and beacon, so 'other' is unreachable unless the caller passes
+     * a wider set to createResourceObserver.
+     */
+    function normaliseInitiatorType(raw) {
+        return KNOWN_INITIATOR_TYPES.has(raw)
+            ? raw
+            : 'other';
+    }
+    /**
+     * Returns null when the entry's value is 0 and the field is a phase timing
+     * expected to be null for cross-origin resources. The browser sets withheld
+     * timing fields to 0 when the server does not send Timing-Allow-Origin.
+     *
+     * Heuristic: responseStart === 0 when duration > 0 indicates the browser
+     * withheld the timing information. Service-worker-intercepted requests and
+     * HTTP/2 reused connections can also produce responseStart === 0; the backend
+     * should treat null as "unavailable", not as "zero duration".
+     */
+    function phaseMs(value, hasTimingAccess) {
+        return hasTimingAccess ? value : null;
+    }
+    /**
+     * Maps a PerformanceResourceTiming entry to a NetworkRequestEvent ready to
+     * push into the collector context.
+     *
+     * @param entry - The PerformanceResourceTiming entry from the observer.
+     * @param sanitizeUrl - Pre-bound URL sanitiser from CollectorContext.
+     */
+    function toResourceEvent(entry, sanitizeUrl) {
+        const extended = entry;
+        // responseStart === 0 (and duration > 0) is the browser's signal that
+        // cross-origin Timing-Allow-Origin headers were absent.
+        const hasTimingAccess = entry.responseStart > 0;
+        const dnsLookupMs = phaseMs(entry.domainLookupEnd - entry.domainLookupStart, hasTimingAccess);
+        const tcpConnectMs = phaseMs(entry.connectEnd - entry.connectStart, hasTimingAccess);
+        const tlsHandshakeMs = phaseMs(entry.connectEnd > 0 && entry.secureConnectionStart > 0
+            ? entry.connectEnd - entry.secureConnectionStart
+            : 0, hasTimingAccess);
+        const ttfbMs = phaseMs(entry.responseStart - entry.requestStart, hasTimingAccess);
+        const responseDownloadMs = phaseMs(entry.responseEnd - entry.responseStart, hasTimingAccess);
+        const transferSize = hasTimingAccess ? entry.transferSize : null;
+        const encodedBodySize = hasTimingAccess ? entry.encodedBodySize : null;
+        const decodedBodySize = hasTimingAccess ? entry.decodedBodySize : null;
+        const nextHopProtocol = hasTimingAccess ? entry.nextHopProtocol || null : null;
+        // deliveryType is a newer addition; safely access via ExtendedResourceEntry.
+        const deliveryType = hasTimingAccess && extended.deliveryType !== undefined
+            ? extended.deliveryType
+            : null;
+        // responseStatus is Chrome 112+. The browser returns 0 for cross-origin /
+        // opaque responses where the real status is withheld — map 0 to null so
+        // downstream consumers don't have to special-case the sentinel.
+        const responseStatusRaw = extended.responseStatus;
+        const responseStatus = responseStatusRaw !== undefined && responseStatusRaw !== 0
+            ? responseStatusRaw
+            : null;
+        return {
+            name: 'network_request',
+            timestamp: Date.now(),
+            performanceTime: entry.startTime + entry.duration,
+            url: sanitizeUrl(entry.name),
+            initiatorType: normaliseInitiatorType(entry.initiatorType),
+            startTime: entry.startTime,
+            durationMs: entry.duration,
+            dnsLookupMs,
+            tcpConnectMs,
+            tlsHandshakeMs,
+            ttfbMs,
+            responseDownloadMs,
+            transferSize,
+            encodedBodySize,
+            decodedBodySize,
+            nextHopProtocol,
+            deliveryType,
+            responseStatus
+        };
+    }
+
+    function noop() { }
+    function createResourceObserver(emit, shouldIgnore, sanitizeUrl, allowedInitiatorTypes = DEFAULT_RESOURCE_INITIATOR_TYPES) {
+        if (typeof PerformanceObserver === 'undefined') {
+            return noop;
+        }
+        let observer = null;
+        try {
+            observer = new PerformanceObserver((list) => {
+                for (const entry of list.getEntries()) {
+                    const resourceEntry = entry;
+                    if (!allowedInitiatorTypes.has(resourceEntry.initiatorType))
+                        continue;
+                    if (shouldIgnore(resourceEntry.name))
+                        continue;
+                    emit(toResourceEvent(resourceEntry, sanitizeUrl));
+                }
             });
             observer.observe({ type: 'resource', buffered: true });
         }
         catch {
-            {
-                // eslint-disable-next-line no-console
-                console.warn(`[TriSDK] ${COLLECTOR_NAME}: PerformanceObserver failed to start`);
-            }
-            return () => void 0;
+            logger.warn(COLLECTOR_NAME, 'PerformanceObserver failed to start');
+            return noop;
         }
         return function disposeResourceObserver() {
             observer?.disconnect();
@@ -1106,43 +1820,38 @@
     }
 
     /**
-     * Returns a predicate that returns true for any URL that should be excluded
-     * from NetworkRequest collection. Used to filter the SDK's own ingest
-     * endpoint to prevent feedback loops.
+     * Returns a predicate that returns true for any URL whose origin matches an
+     * entry in the ignoredOrigins set. Runs against the raw (pre-sanitisation)
+     * URL so SDK ingest URLs are caught before sanitisation could transform them.
+     *
+     * Matching is structural (origin equality) to avoid the false-positive risk of
+     * plain string prefix matching against unrelated hosts that share a prefix.
      */
-    function createUrlIgnorePredicate(ignorePrefixes) {
+    function createOriginIgnorePredicate(ignoredOrigins) {
         return function shouldIgnoreUrl(url) {
-            const normalised = truncateUrl(url);
-            for (const prefix of ignorePrefixes) {
-                if (normalised.startsWith(prefix))
-                    return true;
+            try {
+                return ignoredOrigins.has(new URL(url).origin);
+            }
+            catch {
+                return false;
             }
-            return false;
         };
     }
     /**
      * Creates and starts the NetworkRequest collector. Returns a dispose function
-     * that removes the fetch patch, restores the XHR prototype methods, and
-     * disconnects the PerformanceObserver.
+     * that disconnects the PerformanceObserver.
      */
     function createNetworkRequestInteractionCollector(context) {
         function emit(event) {
             safeSync(() => context.push(event));
         }
-        const shouldIgnore = createUrlIgnorePredicate([context.baseApiUrl]);
-        const stopFetch = installFetchPatch(emit, shouldIgnore);
-        const stopXhr = installXhrPatch(emit, shouldIgnore);
-        const stopObserver = createResourceObserver(emit, shouldIgnore);
+        const shouldIgnore = createOriginIgnorePredicate(context.ignoredOrigins);
+        const stopObserver = createResourceObserver(emit, shouldIgnore, context.sanitizeUrl);
         return function disposeNetworkRequestCollector() {
             stopObserver();
-            stopXhr();
-            stopFetch();
         };
     }
 
-    // TODO
-    // 1. should we support only mouse dynamics?
-    // 2. should we support only pointer move with coalesced events?
     const IDLE_PUSH_INTERVAL$1 = 1500;
     function createPointerMoveCollector(
     /* config - TBD */ context) {
@@ -1150,9 +1859,6 @@
         let pushTimeoutId = null;
         const onPointerMove = safeListener((event) => {
             const pointerEvent = event;
-            // TODO: - decide should we event support this?
-            // Pointer ID switch: a different pointer started moving mid-window.
-            // Flush the in-flight window so the new pointer's data starts cleanly.
             if (pointerMoveWindow && pointerMoveWindow.id !== pointerEvent.pointerId) {
                 context.push(pointerMoveWindow);
                 pointerMoveWindow = null;
@@ -1179,26 +1885,10 @@
                 pointerMoveWindow.samples.force?.push(pointerEvent.pressure);
                 pointerMoveWindow.samples.radius?.push(Math.max(pointerEvent.width, pointerEvent.height));
             }
-            pointerMoveWindow.dispatchedEventCount += 1;
             scheduleIdlePush(context);
         });
         function createPointerMoveWindow(pointerEvent) {
-            let additionalSamples = {
-                tiltX: [],
-                tiltY: [],
-                force: [],
-                radius: []
-            };
-            if (pointerEvent.pointerType === 'pen') {
-                additionalSamples.tiltX = [pointerEvent.tiltX];
-                additionalSamples.tiltY = [pointerEvent.tiltY];
-            }
-            if (pointerEvent.pointerType !== 'mouse') {
-                additionalSamples.force = [pointerEvent.pressure];
-                additionalSamples.radius = [
-                    Math.max(pointerEvent.width, pointerEvent.height)
-                ];
-            }
+            const additionalSamples = getAdditionalSamples(pointerEvent);
             return {
                 name: 'pointer',
                 timestamp: Date.now(),
@@ -1212,10 +1902,8 @@
                     x: [pointerEvent.clientX],
                     y: [pointerEvent.clientY],
                     ts: [pointerEvent.timeStamp],
-                    ...additionalSamples
-                },
-                coalescedRatio: 1,
-                dispatchedEventCount: 1
+                    ...(additionalSamples ?? {})
+                }
             };
         }
         function scheduleIdlePush(context) {
@@ -1229,6 +1917,20 @@
                 pushTimeoutId = null;
             }, IDLE_PUSH_INTERVAL$1);
         }
+        function getAdditionalSamples(pointerEvent) {
+            if (pointerEvent.pointerType === 'mouse') {
+                return null;
+            }
+            const additionalSamples = {
+                force: [pointerEvent.pressure],
+                radius: [Math.max(pointerEvent.width, pointerEvent.height)]
+            };
+            if (pointerEvent.pointerType === 'pen') {
+                additionalSamples.tiltX = [pointerEvent.tiltX];
+                additionalSamples.tiltY = [pointerEvent.tiltY];
+            }
+            return additionalSamples;
+        }
         addEventListener(document, 'pointermove', onPointerMove);
         return () => {
             removeEventListener(document, 'pointermove', onPointerMove);
@@ -1403,20 +2105,20 @@
      *    the cache is silently disabled and the fingerprint is fetched per
      *    page session.
      */
-    const STORAGE_KEY$1 = 'tri:fingerprint';
+    const STORAGE_KEY = 'tri:fingerprint';
     const DEFAULT_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
     let agentPromise = null;
     let visitorIdPromise = null;
     function readCache() {
         try {
-            const raw = localStorage.getItem(STORAGE_KEY$1);
+            const raw = localStorage.getItem(STORAGE_KEY);
             if (!raw)
                 return null;
             const entry = JSON.parse(raw);
             if (typeof entry.visitorId !== 'string' ||
                 typeof entry.expiresAt !== 'number' ||
                 entry.expiresAt <= Date.now()) {
-                localStorage.removeItem(STORAGE_KEY$1);
+                localStorage.removeItem(STORAGE_KEY);
                 return null;
             }
             return {
@@ -1435,7 +2137,7 @@
                 requestId,
                 expiresAt: Date.now() + ttlMs
             };
-            localStorage.setItem(STORAGE_KEY$1, JSON.stringify(entry));
+            localStorage.setItem(STORAGE_KEY, JSON.stringify(entry));
         }
         catch {
             // Best-effort. localStorage may be disabled, full, or partitioned.
@@ -1721,8 +2423,7 @@
                 timestamp: Date.now(),
                 isTrusted: focusEvent.isTrusted,
                 element: context.resolveElement(focusEvent.target),
-                relatedTarget: context.resolveElement(focusEvent.relatedTarget),
-                firesTouchEvents: false // TODO - derive from recent pointer history
+                relatedTarget: context.resolveElement(focusEvent.relatedTarget)
             };
         }
         addEventListener(document, 'focusin', onFocusInteraction);
@@ -2080,6 +2781,7 @@
         });
         function createPointerInteractionEvent(nativeEvent) {
             const pointerEvent = nativeEvent;
+            const additionalProperties = getAdditionalProperties(pointerEvent);
             return {
                 id: pointerEvent.pointerId,
                 name: 'pointer',
@@ -2098,24 +2800,36 @@
                     x: pointerEvent.clientX,
                     y: pointerEvent.clientY
                 },
+                ...additionalProperties
+            };
+        }
+        function getAdditionalProperties(pointerEvent) {
+            if (pointerEvent.pointerType === 'mouse') {
+                return {
+                    button: pointerEvent.button,
+                    buttons: pointerEvent.buttons
+                };
+            }
+            const additionalProperties = {
                 force: pointerEvent.pressure,
-                contact: Math.min(pointerEvent.width, pointerEvent.height),
-                tiltX: pointerEvent.tiltX,
-                tiltY: pointerEvent.tiltY,
-                twist: pointerEvent.twist,
-                button: pointerEvent.button,
-                buttons: pointerEvent.buttons
+                contact: Math.min(pointerEvent.width, pointerEvent.height)
             };
+            if (pointerEvent.pointerType === 'pen') {
+                additionalProperties.tiltX = pointerEvent.tiltX;
+                additionalProperties.tiltY = pointerEvent.tiltY;
+                additionalProperties.twist = pointerEvent.twist;
+            }
+            return additionalProperties;
         }
+        addEventListener(document, 'click', onPointerInteraction);
         addEventListener(document, 'pointerdown', onPointerInteraction);
         addEventListener(document, 'pointerup', onPointerInteraction);
-        addEventListener(document, 'click', onPointerInteraction);
         addEventListener(document, 'dblclick', onPointerInteraction);
         addEventListener(document, 'contextmenu', onPointerInteraction);
         return () => {
+            removeEventListener(document, 'click', onPointerInteraction);
             removeEventListener(document, 'pointerdown', onPointerInteraction);
             removeEventListener(document, 'pointerup', onPointerInteraction);
-            removeEventListener(document, 'click', onPointerInteraction);
             removeEventListener(document, 'dblclick', onPointerInteraction);
             removeEventListener(document, 'contextmenu', onPointerInteraction);
         };
@@ -2311,7 +3025,7 @@
                 width: window.innerWidth,
                 scrollX: window.scrollX,
                 scrollY: window.scrollY,
-                devicePixelRatio: window.devicePixelRatio
+                dpr: window.devicePixelRatio
             };
         }
         addEventListener(window, 'orientationchange', onOrientationViewportInteraction);
@@ -2359,29 +3073,36 @@
 
     function createNavigationLifecycleCollector(
     /* config - TBD */ context) {
-        let previousUrl = document.referrer || '';
+        let previousUrl = context.sanitizeUrl(document.referrer || '');
         function transport(navigationEvent) {
             context.push(navigationEvent);
             previousUrl = navigationEvent.to ?? '';
         }
         const onPageLoad = safeListener(() => {
             const [navEntry] = performance.getEntriesByType('navigation');
-            const pageLoadEvent = createNavigationEvent('load', navEntry?.type ?? 'navigate', { from: document.referrer || null, to: location.href }, performance.timeOrigin, navEntry ? createNavigationTiming(navEntry) : undefined);
+            const pageLoadEvent = createNavigationEvent('load', navEntry?.type ?? 'navigate', {
+                from: document.referrer ? context.sanitizeUrl(document.referrer) : null,
+                to: context.sanitizeUrl(location.href)
+            }, performance.timeOrigin, navEntry ? createNavigationTiming(navEntry) : undefined);
             transport(pageLoadEvent);
         });
         const onNavigate = safeListener((event) => {
             const navigateEvent = event;
-            const navigationEvent = createNavigationEvent('change', navigateEvent.navigationType, { from: previousUrl, to: navigateEvent.destination.url }, performance.timeOrigin);
+            const navigationEvent = createNavigationEvent('change', navigateEvent.navigationType, {
+                from: previousUrl,
+                to: context.sanitizeUrl(navigateEvent.destination.url)
+            }, performance.timeOrigin);
             transport(navigationEvent);
         });
         const onPopstate = safeListener(() => onHistoryStateChange('traverse'));
         const onHashchange = safeListener(() => onHistoryStateChange('hashchange'));
         function onHistoryStateChange(state) {
+            const sanitisedCurrentUrl = context.sanitizeUrl(location.href);
             // pushState/replaceState don't fire for plain anchor clicks (<a href="#x">)
             // so hashchange covers that gap on the fallback path
-            if (state === 'hashchange' && location.href === previousUrl)
+            if (state === 'hashchange' && sanitisedCurrentUrl === previousUrl)
                 return;
-            const historyEvent = createNavigationEvent('change', state, { from: previousUrl, to: location.href }, performance.timeOrigin);
+            const historyEvent = createNavigationEvent('change', state, { from: previousUrl, to: sanitisedCurrentUrl }, performance.timeOrigin);
             transport(historyEvent);
         }
         // --- SPA navigation ---
@@ -2545,7 +3266,7 @@
             create: noopCollectorFactory,
             layer: 'behavioral'
         },
-        networkrequest: {
+        'network-request': {
             create: createNetworkRequestInteractionCollector,
             layer: 'session'
         },
@@ -2561,104 +3282,6 @@
     const COLLECTOR_KEYS = Object.keys(COLLECTORS_CONFIG);
     const COLLECTOR_DEFAULT_ENABLED_STATE = false;
 
-    const DEFAULT_CAPTURE_ELEMENT = 'all';
-    const DEFAULT_CAPTURE_CONTENT = 'on';
-    /**
-     * Resolves the user-supplied TriSDKConfig into a complete, fully-defaulted internal
-     * config. Branches:
-     *  - no config / neither layers nor collectors → all collectors and events enabled,
-     *    no excludes (still honours `capture` and `profileId` when provided)
-     *  - layers map  → collectors enabled iff their layer is true; omitted layers = false
-     *  - collectors  → per-collector/per-event overrides; omitted entries default to enabled
-     *
-     * `capture.level` defaults to `'redact'` across all branches — the safe option.
-     * Hosts that want full PII capture must explicitly set `capture: { level: 'all' }`.
-     */
-    function resolveTriSDKConfig(config) {
-        if (!config?.api?.key || !config?.api?.version || !config?.api?.url) {
-            {
-                // eslint-disable-next-line no-console
-                console.warn('API key, version, and URL are required');
-            }
-        }
-        const { element, content } = config?.capture ?? {};
-        const sdk = {
-            capture: {
-                element: element ?? DEFAULT_CAPTURE_ELEMENT,
-                content: content ?? DEFAULT_CAPTURE_CONTENT
-            },
-            profileId: config?.profileId,
-            api: {
-                key: config?.api.key ?? '',
-                version: config?.api.version ?? '',
-                url: config?.api.url ?? ''
-            }
-        };
-        if (!config ||
-            (config.collectors === undefined && config.layers === undefined)) {
-            return { sdk, collectors: resolveDefaults() };
-        }
-        if (config.collectors !== undefined) {
-            return { sdk, collectors: resolveFromCollectors(config.collectors) };
-        }
-        return { sdk, collectors: resolveFromLayers(config.layers) };
-    }
-    /** Builds a ResolvedCollectorsConfig with every collector and event defaulting to enabled. */
-    function resolveDefaults() {
-        const result = {};
-        for (const key of COLLECTOR_KEYS) {
-            result[key] = resolveCollectorEntry(key, undefined, true);
-        }
-        return result;
-    }
-    /** Builds a ResolvedCollectorsConfig driven by a layer toggle map. Omitted layers default to false. */
-    function resolveFromLayers(layers) {
-        const result = {};
-        for (const key of COLLECTOR_KEYS) {
-            const collectorEnabled = layers[COLLECTORS_CONFIG[key].layer] ?? false;
-            result[key] = resolveCollectorEntry(key, undefined, collectorEnabled);
-        }
-        return result;
-    }
-    /** Builds a ResolvedCollectorsConfig from a per-collector config object. Omitted collectors default to enabled. */
-    function resolveFromCollectors(collectorsInput) {
-        const result = {};
-        for (const key of COLLECTOR_KEYS) {
-            const input = collectorsInput[key];
-            const collectorEnabled = input?.enabled ?? false;
-            result[key] = resolveCollectorEntry(key, input, collectorEnabled);
-        }
-        return result;
-    }
-    /**
-     * Resolves a single collector entry into its fully typed ResolvedCollectorConfig.
-     * One `as` cast at the return boundary is intentional and sound: TypeScript cannot
-     * narrow a conditional type through a runtime length guard.
-     */
-    function resolveCollectorEntry(key, input, collectorEnabled) {
-        const eventNames = COLLECTORS_CONFIG[key]?.events ?? [];
-        if (eventNames.length === 0) {
-            return { enabled: collectorEnabled };
-        }
-        const eventsInput = input?.events;
-        const globalExcludes = eventsInput?.exclude ?? [];
-        const resolvedEvents = {};
-        for (const eventName of eventNames) {
-            const eventEntry = eventsInput?.[eventName];
-            resolvedEvents[eventName] = {
-                enabled: eventEntry?.enabled ?? true,
-                exclude: dedupe([...globalExcludes, ...(eventEntry?.exclude ?? [])])
-            };
-        }
-        return {
-            enabled: collectorEnabled,
-            events: resolvedEvents
-        };
-    }
-    function dedupe(array) {
-        return [...new Set(array)];
-    }
-
     function isCollectorEnabled(collectorKey, config) {
         return config[collectorKey]?.enabled ?? COLLECTOR_DEFAULT_ENABLED_STATE;
     }
@@ -2673,14 +3296,14 @@
             const dispose = collectorConfig.create(context, captureContentLevel);
             disposers.set(collectorKey, dispose);
         }
-        function stop(collectorKey) {
+        function stopCollector(collectorKey) {
             const dispose = disposers.get(collectorKey);
             if (!dispose)
                 return;
             dispose();
             disposers.delete(collectorKey);
         }
-        function stopAll() {
+        function stop() {
             for (const [, dispose] of disposers)
                 dispose();
             disposers.clear();
@@ -2693,39 +3316,42 @@
                 start(collectorKey);
             }
         }
-        return { start, stop, stopAll, isRunning, autocapture };
+        return { start, stopCollector, stop, isRunning, autocapture };
     }
 
     function createLifecycleManager(
     /** config - TBD */ context) {
-        // TODO: think about other lifecycle events that might be useful
-        // - beforeunload
-        // - unload
-        // - freeze
-        // - resume
-        // - readystatechange
-        // - pageshow
         function onVisibilityChange(_) {
             if (document.visibilityState !== 'hidden')
                 return;
-            void context.flush();
+            context.flush();
         }
-        async function onPageHide(_) {
+        function onPageHide(_) {
+            context.flush();
             context.stopTab();
-            void context.flush();
-            const shouldSkipStopActivity = await context.getShouldSkipStopActivity();
+            const shouldSkipStopActivity = context.getShouldSkipStopActivity();
             /* if there are some other tabs open, we don't need to stop the activity, instead we flush events that are left in the queue and early return */
-            if (!shouldSkipStopActivity) {
+            if (shouldSkipStopActivity) {
                 return;
             }
-            context.releaseAliveLock();
             void context.stopActivity();
         }
-        addEventListener(document, 'visibilitychange', onVisibilityChange);
-        addEventListener(window, 'pagehide', onPageHide);
-        return () => {
+        const onConnectionChangeSafe = safeListener(() => context.onConnectionChange());
+        function start() {
+            addEventListener(document, 'visibilitychange', onVisibilityChange);
+            addEventListener(window, 'pagehide', onPageHide);
+            addEventListener(window, 'online', onConnectionChangeSafe);
+            addEventListener(window, 'offline', onConnectionChangeSafe);
+        }
+        function stop() {
             removeEventListener(document, 'visibilitychange', onVisibilityChange);
             removeEventListener(window, 'pagehide', onPageHide);
+            removeEventListener(window, 'online', onConnectionChangeSafe);
+            removeEventListener(window, 'offline', onConnectionChangeSafe);
+        }
+        return {
+            start,
+            stop
         };
     }
 
@@ -3343,7 +3969,6 @@
             }
             catch {
                 // Skip the single corrupted event and preserve the rest of the batch.
-                // Callers track dropped counts via the droppedEvents envelope field.
             }
         }
         return lines.join('\n');
@@ -3497,10 +4122,10 @@
             }
             const requestUrl = baseUrl ? `${baseUrl}${url}` : url;
             const controller = new AbortController();
-            let cancelTimeout = () => void 0;
+            let reqiestTimeoutTimer = null;
             let timedOut = false;
             {
-                cancelTimeout = safeSetTimeout(() => {
+                reqiestTimeoutTimer = safeSetTimeout(() => {
                     timedOut = true;
                     controller.abort();
                 }, timeout);
@@ -3522,7 +4147,7 @@
             /* resolve body from options - string, arraybuffer, object */
             const bodyResult = buildBody(options?.body);
             if (!bodyResult.ok) {
-                cancelTimeout();
+                safeClearTimeout(reqiestTimeoutTimer);
                 removeExternalListener();
                 return { ok: false, kind: 'serialize' };
             }
@@ -3575,7 +4200,7 @@
                 return { ok: false, kind: 'network' };
             }
             finally {
-                cancelTimeout();
+                safeClearTimeout(reqiestTimeoutTimer);
                 removeExternalListener();
             }
         }
@@ -3605,737 +4230,297 @@
                     return fn(earlyToken);
             }
             const tokenAtStart = getToken() ?? '';
-            const initial = await fn(tokenAtStart);
-            if (!shouldRefresh(initial) || options?.refreshable === false)
-                return initial;
-            const newToken = await scheduleSingleFlightRefresh();
-            // Bail if refresh failed or returned the same stale token (e.g. another tab
-            // raced the current tab and both read the pre-refresh value).
-            if (!newToken || newToken === tokenAtStart)
-                return initial;
-            return fn(newToken);
-        }
-        async function attemptRefresh() {
-            try {
-                await refresh();
-                return getToken();
-            }
-            catch (error) {
-                {
-                    // eslint-disable-next-line no-console
-                    console.warn('[TriSDK] auth refresh failed', error);
-                }
-                return null;
-            }
-        }
-        function scheduleSingleFlightRefresh() {
-            if (inflightRefresh) {
-                return inflightRefresh;
-            }
-            inflightRefresh = attemptRefresh().finally(() => {
-                inflightRefresh = null;
-            });
-            return inflightRefresh;
-        }
-        function shouldRefresh(result) {
-            if (result.ok)
-                return false;
-            if (result.kind !== 'client')
-                return false;
-            return REFRESHABLE_STATUS_CODES.includes(result.status);
-        }
-        return { withAuth };
-    }
-
-    function createFalconServiceManager(context) {
-        {
-            if (typeof document === 'undefined' ||
-                typeof globalThis.fetch !== 'function') {
-                // eslint-disable-next-line no-console
-                console.warn('[TriSDK] createFalconServiceManager called in a non-browser environment' +
-                    " — all requests will resolve with { ok: false, kind: 'network' }.");
-            }
-        }
-        const http = createHttpClient({
-            baseUrl: context.api.url,
-            timeout: 10000,
-            profileId: context.profileId,
-            api: {
-                key: context.api.key,
-                version: context.api.version
-            }
-        });
-        const authMiddleware = createAuthMiddleware(context);
-        /** @description Starts a new activity and returns a token — unauthenticated endpoint */
-        async function startActivity() {
-            return http.post('/start-activity');
-        }
-        /** @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 });
-        }
-        /** @description Ingests a batch of events — authenticated endpoint */
-        async function ingest(payload, keepalive) {
-            return authMiddleware.withAuth(async (token) => {
-                // Re-stamp activityId from the ActivityManager at withAuth-callback time so
-                // that if a 401 triggers a token refresh (which mints a new activityId on the
-                // backend), the retried request carries the fresh activityId rather than the
-                // stale one baked into the batch at createBatch() time. Sending a stale
-                // activityId after a refresh would cause the backend to tag the batch as
-                // less reliable. The withAuth callback re-runs on refresh, which is exactly
-                // the point where we need to pull the updated value.
-                const { events, ...rest } = payload;
-                const batchMeta = { ...rest, activityId: context.getActivityId() };
-                let compressed;
-                try {
-                    compressed = await compressIngestPayload(batchMeta, events);
-                }
-                catch {
-                    return { ok: false, kind: 'serialize' };
-                }
-                return http.post('/capture', {
-                    body: compressed.body,
-                    token,
-                    keepalive,
-                    contentType: 'ndjson',
-                    contentEncoding: compressed.type === 'gzip' ? 'gzip' : undefined
-                });
-            });
-        }
-        /** @description Sends a single named event with free-form metadata — authenticated endpoint */
-        async function reportEvent(payload) {
-            return authMiddleware.withAuth((token) => http.post('/report-event', {
-                body: payload,
-                token,
-                contentType: 'json'
-            }));
-        }
-        return {
-            api: {
-                ingest,
-                reportEvent,
-                startActivity,
-                stopActivity
-            }
-        };
-    }
-
-    const TRANSPORT_CONFIG = {
-        flush: {
-            intervalMs: 2000,
-            size: 50
-        },
-        queue: {
-            size: 100
-        }
-    };
-
-    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
-     *
-     * BroadcastChannel fallback backed by localStorage + the window `storage` event.
-     *
-     * ## How it works
-     *
-     * `postMessage` serialises the payload to JSON and writes it under a unique
-     * key (`tri:bcast:<channel>:<sender-uuid>:<seq>`). The `storage` event fires
-     * synchronously in every other tab that has the same origin. The writer then
-     * immediately removes the key so no durable state is left in localStorage.
-     *
-     * ## Same-tab echo prevention
-     *
-     * The browser's `storage` event does NOT fire in the tab that performed the
-     * write — this matches native BroadcastChannel's contract exactly. The
-     * listener in this file therefore never echoes a message back to the sender.
-     * Do NOT change the mechanism (e.g. dispatch a synthetic StorageEvent) without
-     * verifying this invariant is preserved.
-     *
-     * ## Key lifecycle
-     *
-     * 1. Writer: setItem → removeItem (synchronous, back-to-back).
-     * 2. Receiver: sees the storage event for setItem (newValue = payload), parses
-     *    it, then defensively calls removeItem on the key to clean up any entry
-     *    that survived a writer crash. Events for removeItem (newValue = null) are
-     *    ignored.
-     *
-     * ## Failure isolation
-     *
-     * Throws inside JSON.parse, listener callbacks, or localStorage writes are
-     * caught and silently dropped. The channel degrades to a no-op per operation
-     * rather than crashing the host page (rule #2 of CLAUDE.md).
-     */
-    const STORAGE_KEY_PREFIX = 'tri:bcast:';
-    /**
-     * BroadcastChannel-like backed by localStorage and the window `storage` event.
-     * Used as a fallback on browsers that do not support native BroadcastChannel.
-     */
-    class StorageEventChannel {
-        constructor(name) {
-            this.seq = 0;
-            this.closed = false;
-            this.listeners = new Set();
-            /**
-             * Arrow property so `this` is bound when passed directly to
-             * addEventListener / removeEventListener.
-             */
-            this.onStorageEvent = (event) => {
-                if (this.closed)
-                    return;
-                const keyPrefix = `${STORAGE_KEY_PREFIX}${this.channelName}:`;
-                if (!event.key || !event.key.startsWith(keyPrefix))
-                    return;
-                // Ignore the removal event produced by the writer's own removeItem call.
-                if (event.newValue === null)
-                    return;
-                // Defensive cleanup: the writer should have removed this already, but
-                // guard against crashes mid-write that leave a stale entry.
-                safeSync(() => LocalStorage.remove(event.key));
-                let data;
-                try {
-                    data = JSON.parse(event.newValue);
-                }
-                catch {
-                    return;
-                }
-                const dispatched = { data };
-                for (const listener of this.listeners) {
-                    safeSync(() => listener(dispatched));
-                }
-            };
-            this.channelName = name;
-            this.senderId = generateUUID();
-            window.addEventListener('storage', this.onStorageEvent);
-        }
-        /**
-         * Serialises `message` to JSON, writes it under a unique key, then removes
-         * it immediately. The write triggers the `storage` event in all other tabs
-         * on the same origin; the removal keeps localStorage clean.
-         *
-         * Payload size is not explicitly bounded here because tab-discovery messages
-         * are tiny plain-object JSON. If the channel is ever used for larger payloads
-         * this assumption must be revisited against the ~5 MB localStorage quota.
-         */
-        postMessage(message) {
-            if (this.closed)
-                return;
-            const key = `${STORAGE_KEY_PREFIX}${this.channelName}:${this.senderId}:${this.seq++}`;
-            safeSync(() => {
-                LocalStorage.set(key, message);
-                // The storage event fires in other tabs upon setItem; remove the key
-                // immediately so no stale entry persists if a subsequent read races.
-                LocalStorage.remove(key);
-            });
-        }
-        addEventListener(_type, listener) {
-            this.listeners.add(listener);
-        }
-        removeEventListener(_type, listener) {
-            this.listeners.delete(listener);
-        }
-        /** Detaches the storage listener and prevents further dispatch. */
-        close() {
-            if (this.closed)
-                return;
-            this.closed = true;
-            window.removeEventListener('storage', this.onStorageEvent);
-            this.listeners.clear();
-        }
-    }
-
-    /**
-     * @module broadcast-channel
-     *
-     * Ponyfill selector for BroadcastChannel.
-     *
-     * ## Ponyfill, not polyfill
-     *
-     * This module exports `TriBroadcastChannel` — a local binding that resolves
-     * to native BroadcastChannel when available, a localStorage fallback when not,
-     * or a no-op when neither storage mechanism is usable (e.g. private mode with
-     * storage blocked). The host page's `globalThis` is never modified.
-     *
-     * ## Detection order
-     *
-     * 1. Native `BroadcastChannel` — detected via `typeof BroadcastChannel === 'function'`
-     *    so any polyfill the host app installed is transparently honoured.
-     * 2. `StorageEventChannel` — requires `window` and a writable `localStorage`.
-     *    Availability is probed once at module load via a setItem/getItem/removeItem
-     *    round-trip, matching the approach used in `lib/immortal-db/storages/web.ts`.
-     * 3. `NoopChannel` — silent fallback when neither option is available. Emits
-     *    a single `true`-gated console.warn at construction time so developers
-     *    can see that tab discovery is disabled.
-     *
-     * ## Module-load detection
-     *
-     * Selection happens once when this module is first imported and the result is
-     * cached in `TriBroadcastChannel`. This is intentional: re-probing on every
-     * constructor call would be wasteful and storage availability does not change
-     * within a session.
-     */
-    // ─── No-op channel ────────────────────────────────────────────────────────────
-    /**
-     * Silent fallback used when neither native BroadcastChannel nor localStorage
-     * is available. All operations are no-ops. Tab count will stay at 1.
-     * Emits a single `true` console.warn at construction so developers can
-     * see that cross-tab discovery is disabled.
-     */
-    class NoopChannel {
-        constructor(_name) {
-            {
-                // eslint-disable-next-line no-console
-                console.warn('[TriSDK] BroadcastChannel is unavailable and localStorage is not ' +
-                    'writable in this context. Cross-tab discovery is disabled; tab ' +
-                    'count will always be reported as 1.');
-            }
-        }
-        postMessage(_message) { }
-        addEventListener(_type, _listener) { }
-        removeEventListener(_type, _listener) { }
-        close() { }
-    }
-    // ─── Availability probes ──────────────────────────────────────────────────────
-    /**
-     * Returns true if `localStorage` is present and can be written to.
-     * Catches: Safari private mode (throws on setItem), storage disabled by
-     * policy, quota-exhausted state.
-     *
-     * Uses `typeof Storage !== 'undefined'` as a fast pre-check; the round-trip
-     * write is needed because that check alone is unreliable in embedded contexts.
-     */
-    function isLocalStorageWritable() {
-        if (typeof Storage === 'undefined' || typeof window === 'undefined') {
-            return false;
-        }
-        try {
-            const probeKey = '__tri_bcast_probe__';
-            localStorage.setItem(probeKey, '1');
-            const ok = localStorage.getItem(probeKey) === '1';
-            localStorage.removeItem(probeKey);
-            return ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    // ─── Selector ─────────────────────────────────────────────────────────────────
-    function pickChannel() {
-        if (typeof BroadcastChannel === 'function') {
-            return BroadcastChannel;
-        }
-        if (isLocalStorageWritable()) {
-            return StorageEventChannel;
-        }
-        return NoopChannel;
-    }
-    /**
-     * Drop-in BroadcastChannel constructor that works across environments.
-     *
-     * Resolves at module load to:
-     * - Native `BroadcastChannel` when available (including host-app polyfills).
-     * - `StorageEventChannel` (localStorage + storage event) on older browsers.
-     * - `NoopChannel` when neither is usable.
-     *
-     * Usage is identical to native BroadcastChannel:
-     * ```ts
-     * const channel = new TriBroadcastChannel('my-channel')
-     * channel.addEventListener('message', handler)
-     * channel.postMessage({ type: 'hello' })
-     * channel.close()
-     * ```
-     */
-    const TriBroadcastChannel = pickChannel();
-
-    const STORAGE_KEY = 'tri:tabId';
-    const CHANNEL_NAME = 'tri:tab_channel';
-    const HEARTBEAT_INTERVAL_MS = 2000;
-    const IDLE_HEARTBEAT_INTERVAL_MS = 3 * HEARTBEAT_INTERVAL_MS;
-    /* setting to 1s due to browser tab throttling to 1Hz so 500ms could be missed */
-    const COUNT_EMIT_DEBOUNCE_MS = 1000;
-    const ALIVE_LOCK_NAME = 'tri:tab:alive';
-    class TabManager {
-        constructor(context) {
-            this.context = context;
-            this.tabId = '';
-            this.started = false;
-            this.broadcastChannel = null;
-            this.heartbeatTimer = null;
-            this.countEmitTimer = null;
-            this.peers = new Map();
-            this.lastEmittedCount = -1;
-            this.releaseAlive = null;
-            this.bound_OnBroadcastMessage = null;
-        }
-        async start() {
-            if (this.started)
-                return;
-            this.started = true;
-            this.tabId = this._generateTabId();
-            await this._setupAliveLock();
-            this._openChannel();
-            this._broadcast({ type: 'hello', tabId: this.tabId, ts: Date.now() });
-            this._startHeartbeat();
-            this._emitTabState('active');
-            this._scheduleCountEmit();
-        }
-        stop() {
-            if (!this.started)
-                return;
-            this.started = false;
-            this._emitTabState('inactive');
-            this._broadcast({ type: 'bye', tabId: this.tabId, ts: Date.now() });
-            /* there is no increment because we are emitting count of the remaining tabs */
-            this._emitTabCount(this._sweepPeers());
-            this._stopHeartbeat();
-            this._cancelCountEmit();
-            this._closeChannel();
-            this.releaseAliveLock();
-        }
-        getTabId() {
-            return this.tabId;
-        }
-        async queryTabsNumber() {
-            const totalTabsNumber = this.peers.size + 1;
-            const holders = await queryWebLockHolders(ALIVE_LOCK_NAME);
-            return holders?.length ?? totalTabsNumber;
-        }
-        releaseAliveLock() {
-            this.releaseAlive?.();
-            this.releaseAlive = null;
+            const initial = await fn(tokenAtStart);
+            if (!shouldRefresh(initial) || options?.refreshable === false)
+                return initial;
+            const newToken = await scheduleSingleFlightRefresh();
+            // Bail if refresh failed or returned the same stale token (e.g. another tab
+            // raced the current tab and both read the pre-refresh value).
+            if (!newToken || newToken === tokenAtStart)
+                return initial;
+            return fn(newToken);
         }
-        _openChannel() {
+        async function attemptRefresh() {
             try {
-                this.broadcastChannel = new TriBroadcastChannel(CHANNEL_NAME);
-                this.bound_OnBroadcastMessage = this._onBroadcastMessage.bind(this);
-                this.broadcastChannel.addEventListener('message', this.bound_OnBroadcastMessage);
+                await refresh();
+                return getToken();
             }
             catch (error) {
-                {
-                    // eslint-disable-next-line no-console
-                    console.warn('[TriSDK] failed to open broadcast channel:', error);
-                }
+                logger.warn('AuthMiddleware', 'auth refresh failed', error);
+                return null;
             }
         }
-        _closeChannel() {
-            try {
-                if (!this.broadcastChannel)
-                    return;
-                if (this.bound_OnBroadcastMessage) {
-                    this.broadcastChannel.removeEventListener('message', this.bound_OnBroadcastMessage);
-                }
-                this.broadcastChannel.close();
-            }
-            catch {
-                // do nothing
-            }
-            finally {
-                this.broadcastChannel = null;
-                this.bound_OnBroadcastMessage = null;
+        function scheduleSingleFlightRefresh() {
+            if (inflightRefresh) {
+                return inflightRefresh;
             }
+            inflightRefresh = attemptRefresh().finally(() => {
+                inflightRefresh = null;
+            });
+            return inflightRefresh;
         }
-        _startHeartbeat() {
-            this.heartbeatTimer = setInterval(() => {
-                const now = Date.now();
-                this._broadcast({
-                    type: 'heartbeat',
-                    tabId: this.tabId,
-                    ts: now
-                });
-            }, HEARTBEAT_INTERVAL_MS);
-        }
-        _stopHeartbeat() {
-            if (this.heartbeatTimer != null) {
-                clearInterval(this.heartbeatTimer);
-                this.heartbeatTimer = null;
-            }
+        function shouldRefresh(result) {
+            if (result.ok)
+                return false;
+            if (result.kind !== 'client')
+                return false;
+            return REFRESHABLE_STATUS_CODES.includes(result.status);
         }
-        _scheduleCountEmit() {
-            if (this.countEmitTimer != null)
-                clearTimeout(this.countEmitTimer);
-            this.countEmitTimer = setTimeout(() => {
-                this.countEmitTimer = null;
-                const count = this._sweepPeers() + 1;
-                if (count === this.lastEmittedCount)
-                    return;
-                this.lastEmittedCount = count;
-                this._emitTabCount(count);
-            }, COUNT_EMIT_DEBOUNCE_MS);
+        return { withAuth };
+    }
+
+    function createFalconServiceManager(context) {
+        if (typeof document === 'undefined' ||
+            typeof globalThis.fetch !== 'function') {
+            logger.warn('FalconService', 'createFalconServiceManager called in a non-browser environment' +
+                " — all requests will resolve with { ok: false, kind: 'network' }.");
         }
-        _cancelCountEmit() {
-            if (this.countEmitTimer != null) {
-                clearTimeout(this.countEmitTimer);
-                this.countEmitTimer = null;
+        const http = createHttpClient({
+            baseUrl: `${context.api.url}/api/v1/events`,
+            timeout: 10000,
+            profileId: context.profileId,
+            api: {
+                key: context.api.key,
+                version: context.api.version
             }
+        });
+        const authMiddleware = createAuthMiddleware(context);
+        /** @description Starts a new activity and returns a token — unauthenticated endpoint */
+        async function startActivity() {
+            return http.post('/start-activity');
         }
-        _broadcast(message) {
-            try {
-                if (!this.broadcastChannel)
-                    return;
-                this.broadcastChannel.postMessage(message);
-            }
-            catch {
-                {
-                    // eslint-disable-next-line no-console
-                    console.warn('[TriSDK] failed to broadcast message:', message);
-                }
-            }
+        /** @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 });
         }
-        _onBroadcastMessage(event) {
-            const { type, tabId } = event.data;
-            if (tabId === this.tabId)
-                return;
-            const receivedAt = Date.now();
-            if (type === 'hello') {
-                this._broadcast({
-                    type: 'ack',
-                    tabId: this.tabId,
-                    ts: receivedAt,
-                    to: tabId
+        /** @description Ingests a batch of events — authenticated endpoint */
+        async function ingest(payload, keepalive) {
+            return authMiddleware.withAuth(async (token) => {
+                // Re-stamp activityId from the ActivityManager at withAuth-callback time so
+                // that if a 401 triggers a token refresh (which mints a new activityId on the
+                // backend), the retried request carries the fresh activityId rather than the
+                // stale one baked into the batch at createBatch() time. Sending a stale
+                // activityId after a refresh would cause the backend to tag the batch as
+                // less reliable. The withAuth callback re-runs on refresh, which is exactly
+                // the point where we need to pull the updated value.
+                const { events, ...batchMeta } = payload;
+                const adjustedBatchMeta = {
+                    ...batchMeta,
+                    activityId: context.getActivityId()
+                };
+                let compressed;
+                try {
+                    compressed = await compressIngestPayload(adjustedBatchMeta, events);
+                }
+                catch {
+                    return { ok: false, kind: 'serialize' };
+                }
+                return http.post('/capture', {
+                    body: compressed.body,
+                    token,
+                    keepalive,
+                    contentType: 'ndjson',
+                    contentEncoding: compressed.type === 'gzip' ? 'gzip' : undefined
                 });
-                this.peers.set(tabId, receivedAt);
-            }
-            else if (type === 'heartbeat') {
-                this.peers.set(tabId, receivedAt);
-            }
-            else if (type === 'ack') {
-                this.peers.set(tabId, receivedAt);
-            }
-            else if (type === 'bye') {
-                this.peers.delete(tabId);
-            }
-        }
-        _emitTabCount(value) {
-            this.context.push({
-                name: 'tab',
-                type: 'count',
-                tabId: this.tabId,
-                timestamp: Date.now(),
-                value
             });
         }
-        _emitTabState(value, tabId) {
-            this.context.push({
-                name: 'tab',
-                type: 'state',
-                tabId: this.tabId,
-                timestamp: Date.now(),
-                value
-            });
+        /** @description Sends a single named event with free-form metadata — authenticated endpoint */
+        async function reportEvent(payload) {
+            return authMiddleware.withAuth((token) => http.post('/report-event', {
+                body: payload,
+                token,
+                contentType: 'json'
+            }));
         }
-        _generateTabId() {
-            const existing = SessionStorage.get(STORAGE_KEY);
-            if (existing)
-                return existing;
-            const fresh = generateUUID();
-            SessionStorage.set(STORAGE_KEY, fresh);
-            return fresh;
+        return {
+            api: {
+                ingest,
+                reportEvent,
+                startActivity,
+                stopActivity
+            }
+        };
+    }
+
+    class EventReportManager {
+        constructor(context) {
+            this.context = context;
         }
-        _sweepPeers(now = Date.now()) {
-            let active = 0;
-            for (const [tabId, timestamp] of this.peers.entries()) {
-                if (now - timestamp >= IDLE_HEARTBEAT_INTERVAL_MS) {
-                    this.peers.delete(tabId);
-                }
-                else {
-                    active++;
+        /** No-op. Present for lifecycle symmetry with other managers. */
+        stop() { }
+        async report(name, metadata) {
+            const reportEventPayload = {
+                name,
+                metadata,
+                timestamp: Date.now(),
+                activityId: this.context.getActivityId() ?? ''
+            };
+            try {
+                const result = await this.context.reportEvent(reportEventPayload);
+                if (result.ok) {
+                    return result;
                 }
+                logger.warn('EventReport', 'Failed to report event:', name, metadata, 'with result:', result);
+            }
+            catch (error) {
+                logger.warn('EventReport', 'Failed to report event:', name, metadata, 'with error:', error);
             }
-            return active;
-        }
-        async _setupAliveLock() {
-            return new Promise((acquired) => {
-                void withSharedWebLock(ALIVE_LOCK_NAME, () => {
-                    acquired();
-                    return new Promise((resolve) => {
-                        this.releaseAlive = resolve;
-                    });
-                });
-            });
         }
     }
 
-    /*! js-cookie v3.0.5 | MIT */
-    /* eslint-disable no-var */
-    function assign (target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) {
-          target[key] = source[key];
-        }
-      }
-      return target
-    }
-    /* eslint-enable no-var */
-
-    /* eslint-disable no-var */
-    var defaultConverter = {
-      read: function (value) {
+    /**
+     * 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, decodeURIComponent)
-      },
-      write: function (value) {
-        return encodeURIComponent(value).replace(
-          /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
-          decodeURIComponent
-        )
-      }
-    };
-    /* eslint-enable no-var */
-
-    /* eslint-disable no-var */
-
-    function init (converter, defaultAttributes) {
-      function set (name, value, attributes) {
-        if (typeof document === 'undefined') {
-          return
+            value = value.slice(1, -1);
         }
-
-        attributes = assign({}, defaultAttributes, attributes);
-
-        if (typeof attributes.expires === 'number') {
-          attributes.expires = new Date(Date.now() + attributes.expires * 864e5);
+        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.expires) {
-          attributes.expires = attributes.expires.toUTCString();
+        if (attributes.path !== undefined) {
+            result += '; Path=' + attributes.path;
         }
-
-        name = encodeURIComponent(name)
-          .replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent)
-          .replace(/[()]/g, escape);
-
-        var stringifiedAttributes = '';
-        for (var attributeName in attributes) {
-          if (!attributes[attributeName]) {
-            continue
-          }
-
-          stringifiedAttributes += '; ' + attributeName;
-
-          if (attributes[attributeName] === true) {
-            continue
-          }
-
-          // Considers RFC 6265 section 5.2:
-          // ...
-          // 3.  If the remaining unparsed-attributes contains a %x3B (";")
-          //     character:
-          // Consume the characters of the unparsed-attributes up to,
-          // not including, the first %x3B (";") character.
-          // ...
-          stringifiedAttributes += '=' + attributes[attributeName].split(';')[0];
+        if (attributes.domain !== undefined) {
+            result += '; Domain=' + attributes.domain;
         }
-
-        return (document.cookie =
-          name + '=' + converter.write(value, name) + stringifiedAttributes)
-      }
-
-      function get (name) {
-        if (typeof document === 'undefined' || (arguments.length && !name)) {
-          return
+        if (attributes.sameSite !== undefined) {
+            const capitalised = attributes.sameSite.charAt(0).toUpperCase() +
+                attributes.sameSite.slice(1);
+            result += '; SameSite=' + capitalised;
         }
-
-        // To prevent the for loop in the first place assign an empty array
-        // in case there are no cookies at all.
-        var cookies = document.cookie ? document.cookie.split('; ') : [];
-        var jar = {};
-        for (var i = 0; i < cookies.length; i++) {
-          var parts = cookies[i].split('=');
-          var value = parts.slice(1).join('=');
-
-          try {
-            var found = decodeURIComponent(parts[0]);
-            jar[found] = converter.read(value, found);
-
-            if (name === found) {
-              break
+        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);
             }
-          } catch (e) {}
-        }
-
-        return name ? jar[name] : jar
-      }
-
-      return Object.create(
-        {
-          set,
-          get,
-          remove: function (name, attributes) {
-            set(
-              name,
-              '',
-              assign({}, attributes, {
-                expires: -1
-              })
-            );
-          },
-          withAttributes: function (attributes) {
-            return init(this.converter, assign({}, this.attributes, attributes))
-          },
-          withConverter: function (converter) {
-            return init(assign({}, this.converter, converter), this.attributes)
-          }
-        },
-        {
-          attributes: { value: Object.freeze(defaultAttributes) },
-          converter: { value: Object.freeze(converter) }
         }
-      )
+        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 });
     }
-
-    var api = init(defaultConverter, { path: '/' });
 
     /**
      * Hard cap on cookie size. Browsers vary slightly (the spec is 4096 bytes
@@ -4344,10 +4529,15 @@
      */
     const COOKIE_BYTE_BUDGET = 4000;
     /**
-     * Adapter over js-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.
+     * 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 = {}) {
@@ -4366,9 +4556,9 @@
                 return false;
             try {
                 const probeKey = `__immortal_probe_${generateUUID()}__`;
-                safeSync(() => api.set(probeKey, '1', { path: '/' }));
-                const ok = safeSync(() => api.get(probeKey)) === '1';
-                safeSync(() => api.remove(probeKey, { path: '/' }));
+                safeSync(() => setCookie(probeKey, '1', { path: '/' }));
+                const ok = safeSync(() => getCookie(probeKey)) === '1';
+                safeSync(() => removeCookie(probeKey, { path: '/' }));
                 return ok;
             }
             catch {
@@ -4376,7 +4566,7 @@
             }
         }
         async get(key) {
-            const value = safeSync(() => api.get(key));
+            const value = safeSync(() => getCookie(key));
             return value === undefined ? null : value;
         }
         async set(key, value) {
@@ -4384,13 +4574,13 @@
                 throw new Error(`CookieStorage: combined key+value size (${key.length + value.length}) ` +
                     `exceeds budget (${COOKIE_BYTE_BUDGET}) for key "${key}"`);
             }
-            safeSync(() => api.set(key, value, this.attrs));
+            safeSync(() => setCookie(key, value, this.attrs));
         }
         async remove(key) {
             // Path must match the original write to actually clear the cookie.
-            safeSync(() => api.remove(key, {
+            safeSync(() => removeCookie(key, {
                 path: this.attrs.path,
-                domain: this.attrs.domain
+                domain: this.attrs.domain,
             }));
         }
         static getCookieAttributes(options) {
@@ -4398,7 +4588,7 @@
                 expires: options.expires ?? 365,
                 path: options.path ?? '/',
                 sameSite: options.sameSite ?? 'lax',
-                secure: options.secure ?? false
+                secure: options.secure ?? false,
             };
         }
     }
@@ -4545,7 +4735,7 @@
             this._initialized = false;
             this._initPromise = null;
             this._configured = options.stores ?? ImmortalDB._defaultStores();
-            this._keyPrefix = options.keyPrefix ?? 'tri:_immortal_';
+            this._keyPrefix = options.keyPrefix ?? '_tri_immortal_';
             this._onError = options.onError ?? (() => { });
         }
         /** Names of backends that passed availability probing. Useful for diagnostics. */
@@ -5297,183 +5487,495 @@
         };
     }
 
-    let TriSDK$1 = class TriSDK {
-        constructor() {
-            this.initialized = false;
-            this.activityManager = null;
-            this.transportManager = null;
-            this.tabManager = null;
-            this.collectorManager = null;
-            this.falconServiceManager = null;
+    const TRANSPORT_CONFIG = {
+        flush: {
+            intervalMs: 2000,
+            maxIntervalMs: 30000,
+            size: 50,
+            backoffFailureThreshold: 2
+        },
+        queue: {
+            size: 100
         }
-        static get instance() {
-            if (!TriSDK._instance) {
-                TriSDK._instance = new TriSDK();
-            }
-            return TriSDK._instance;
+    };
+    /** Default `capture.element` level — `'redact'` is the PII-safe option. */
+    const DEFAULT_CAPTURE_ELEMENT = 'redact';
+    /** Default `capture.content` level. */
+    const DEFAULT_CAPTURE_CONTENT = 'on';
+
+    /**
+     * UUID v4 (and v1/v5 — same shape). Case-insensitive to cover uppercase variants.
+     * Example: `550e8400-e29b-41d4-a716-446655440000`
+     */
+    const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    /** Binary number literal embedded in a path. Example: `0b1010` */
+    const NUMBER_LITERAL_BINARY_PATTERN = /^0b[01]+$/i;
+    /** Octal number literal embedded in a path. Example: `0o777` */
+    const NUMBER_LITERAL_OCTAL_PATTERN = /^0o[0-7]+$/i;
+    /** Hex number literal embedded in a path. Example: `0x1A2B` */
+    const NUMBER_LITERAL_HEX_PATTERN = /^0x[0-9a-f]+$/i;
+    /**
+     * Algorithm-prefixed digest. Prefix is 1–13 lowercase alphanumeric chars,
+     * followed by a colon, then ≥6 chars of the digest.
+     * Example: `sha256:e3b0c44298fc1c149afbf4c8996fb924…`
+     */
+    const PREFIXED_HASH_PATTERN = /^[a-z][a-z0-9]{1,12}:[A-Za-z0-9+/=_-]{6,}$/i;
+    /**
+     * Stripe-style prefixed ID: 2–8 lowercase letters, underscore, then ≥3
+     * alphanumeric chars that include at least one digit. The digit lookahead
+     * prevents matching plain slug-style segments like `my_blog` or `app_dir`.
+     * Example: `sub_456`, `cus_NDdj1aPdHbHj1mwa`
+     */
+    const PREFIXED_ID_PATTERN = /^[a-z]{2,8}_(?=.*\d)[A-Za-z0-9]{3,}$/;
+    /**
+     * All-digit numeric IDs four or more characters long (shorter ones are
+     * pagination/version numbers and should be preserved).
+     * Example: `49827341`
+     */
+    const NUMERIC_ID_PATTERN = /^\d{4,}$/;
+    /** Segment containing `@` — almost always an email address in a path. */
+    const EMAIL_PATTERN = /@/;
+    /**
+     * Full JSON Web Token: three base64url groups separated by dots.
+     * Header and signature must each be ≥10 chars to avoid false-positives on
+     * versioned filenames like `style.min.css` or `bundle.abc123.js`.
+     * Example: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0In0.SflKxw…`
+     */
+    const JWT_PATTERN = /^[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{10,}$/;
+    /**
+     * Long base64url blob (≥20 chars, no dots). Catches opaque session tokens,
+     * PKCE code verifiers, and other single-segment encoded values.
+     * Example: `dGhpcyBpcyBhIHRlc3Q`
+     */
+    const BASE64URL_PATTERN = /^[A-Za-z0-9_-]{20,}={0,2}$/;
+    /**
+     * Short Git SHA (7+ hex chars) and any other pure-hex identifier. The
+     * threshold of 7 matches the canonical Git short-SHA length and subsumes
+     * longer hex digests. Known acceptable false-positive: 7-char English words
+     * that happen to be all-hex (`defaced`, `feedface`) — we accept this because
+     * the sanitiser's bias is toward redaction.
+     * Example: `a1b2c3d`, `deadbeefcafe1234`, `abc123def456`
+     */
+    const HEX_PATTERN = /^[0-9a-f]{7,}$/i;
+    /**
+     * Ordered list of patterns used to decide whether a path segment should be
+     * replaced with `:param`. Evaluation stops at the first match. Order is
+     * deliberate: UUID before generic hex (UUID contains hyphens and is more
+     * specific), number literals before the catch-all hex pattern, JWT before
+     * the long base64url pattern.
+     *
+     * Patterns in order:
+     * 1. UUID v4/v1/v5
+     * 2. Binary number literal (`0b…`)
+     * 3. Octal number literal (`0o…`)
+     * 4. Hex number literal (`0x…`)
+     * 5. Algorithm-prefixed digest (`sha256:…`, `md5:…`)
+     * 6. Stripe-style prefixed ID (`sub_456`, `cus_…`)
+     * 7. Bare numeric ID (≥4 digits)
+     * 8. Email in path (`@`)
+     * 9. Full JWT (three base64url parts separated by dots)
+     * 10. Long base64url blob (≥20 chars, no dots)
+     * 11. Pure-hex identifier (≥7 chars, covers Git SHAs and longer digests)
+     */
+    const IDENTIFIER_PATTERNS = [
+        UUID_PATTERN,
+        NUMBER_LITERAL_BINARY_PATTERN,
+        NUMBER_LITERAL_OCTAL_PATTERN,
+        NUMBER_LITERAL_HEX_PATTERN,
+        PREFIXED_HASH_PATTERN,
+        PREFIXED_ID_PATTERN,
+        NUMERIC_ID_PATTERN,
+        EMAIL_PATTERN,
+        JWT_PATTERN,
+        BASE64URL_PATTERN,
+        HEX_PATTERN
+    ];
+    function isIdentifierSegment(segment) {
+        for (const pattern of IDENTIFIER_PATTERNS) {
+            if (pattern.test(segment))
+                return true;
         }
-        /**
-         * Initialises the TRI SDK. Synchronous and idempotent — a second call is a
-         * no-op. Safe to call in SSR environments; if `document` is unavailable the
-         * function logs an error and returns without throwing.
-         */
-        start(config) {
-            void this._start(config);
+        return false;
+    }
+    function redactPathSegments(pathname) {
+        return pathname
+            .split('/')
+            .map((segment) => segment !== '' && isIdentifierSegment(segment) ? ':param' : segment)
+            .join('/');
+    }
+    /**
+     * Returns a sanitised URL string with PII-carrying components stripped or
+     * replaced. Designed for consumer-protection: prevents raw secrets
+     * (OAuth tokens, API keys, session tokens, emails, account IDs) from
+     * leaving the browser via the TRI SDK wire payload.
+     *
+     * Sanitisation steps, in order:
+     * 1. Parse via `new URL`. Relative URLs are resolved against `location.href`.
+     *    Returns `''` for strings that cannot be parsed.
+     * 2. Strip `username` and `password` (embedded credentials).
+     * 3. Strip `hash` (OAuth implicit-flow tokens, hash-router state).
+     * 4. Redact all query-string values to `<redacted>` (keys are preserved for
+     *    endpoint cardinality analysis; values are almost never needed for fraud
+     *    signal and routinely carry bearer tokens, magic-link codes, etc.).
+     * 5. Tokenise path segments that look like identifiers → `:param`. Recognised
+     *    shapes: UUIDs, binary/octal/hex number literals, algorithm-prefixed
+     *    digests (`sha256:…`), Stripe-style prefixed IDs (`sub_456`), bare
+     *    numeric IDs (≥4 digits), email-in-path, full JWTs (three base64url
+     *    parts), long base64url blobs (≥20 chars), and pure-hex strings (≥7
+     *    chars, covering Git short SHAs and longer digests). The hostname is
+     *    preserved verbatim (third-party domain is a valuable signal).
+     * 6. Cap the result at `MAX_URL_LENGTH` UTF-16 code units **after** redaction,
+     *    so cuts can never strand half an unredacted token.
+     *
+     * This is policy, not a security boundary: a script with same-realm execution
+     * can read URLs directly. The goal is preventing accidental leakage to the
+     * TRI backend by SDK consumers who have not reviewed every URL their app
+     * issues.
+     */
+    function defaultSanitizeUrl(rawUrl) {
+        try {
+            const url = new URL(rawUrl, location.href);
+            url.username = '';
+            url.password = '';
+            url.hash = '';
+            // Build the sanitised query string with literal `<redacted>` values.
+            // Using URLSearchParams.set() would percent-encode `<` and `>`, producing
+            // `%3Credacted%3E` on the wire. We construct the search manually to keep
+            // the human-readable placeholder intact.
+            const paramKeys = [...url.searchParams.keys()];
+            const sanitisedSearch = paramKeys.length > 0
+                ? '?' +
+                    paramKeys
+                        .map((key) => `${encodeURIComponent(key)}=<redacted>`)
+                        .join('&')
+                : '';
+            url.search = '';
+            url.pathname = redactPathSegments(url.pathname);
+            const result = url.origin + url.pathname + sanitisedSearch;
+            return result.length > MAX_URL_LENGTH
+                ? result.slice(0, MAX_URL_LENGTH)
+                : result;
         }
-        async _start(config) {
-            if (this._shouldEarlyEscapeInit()) {
-                return false;
-            }
-            try {
-                const { collectors: collectorsConfig, sdk: sdkConfig } = resolveTriSDKConfig(config);
-                /** Falcon Service Manager */
-                const falconServiceManagerContext = this._createFalconServiceManagerContext(sdkConfig);
-                this.falconServiceManager = createFalconServiceManager(falconServiceManagerContext);
-                /** Activity Manager */
-                const activityManagerContext = this._createActivityManagerContext();
-                /* initialize the activity manager and start activity to get token */
-                this.activityManager = new ActivityManager(activityManagerContext);
-                await this.activityManager.start();
-                /** Transport Manager */
-                const transportManagerContext = this._createTransportManagerContext();
-                this.transportManager = new TransportManager(TRANSPORT_CONFIG, transportManagerContext);
-                this.transportManager.start();
-                /** Tab Manager */
-                const tabManagerContext = this._createTabManagerContext();
-                this.tabManager = new TabManager(tabManagerContext);
-                await this.tabManager.start();
-                /** Lifecycle Manager */
-                const lifecycleManagerContext = this._createLifecycleManagerContext();
-                createLifecycleManager(lifecycleManagerContext);
-                /** Element Context Processor */
-                const elementContextProcessor = createElementContextProcessor(sdkConfig.capture?.element);
-                /** Collectors Manager */
-                const collectorsManagerContext = this._createCollectorsManagerContext(elementContextProcessor, sdkConfig);
-                this.collectorManager = createCollectorsManager(collectorsManagerContext, collectorsConfig, sdkConfig.capture?.content);
-                this.collectorManager.autocapture();
-                this.initialized = true;
-                return true;
-            }
-            catch (error) {
-                {
-                    // eslint-disable-next-line no-console
-                    console.error('[TriSDK] init() failed:', error);
-                }
-                return false;
-            }
+        catch {
+            return '';
         }
-        /**
-         * Reports a host-defined event to the TRI backend. Fire-and-forget — never
-         * throws and never returns a promise the host must handle. Drops the event
-         * silently (with a dev warning) if called before `init`.
-         */
-        reportEvent(name, metadata) {
-            // TODO - think about creating EventReporterManager that will handle reportEvent and this public facing method will only be a facade for it
-            if (this._shouldEarlyEscapeReportEvent()) {
-                return;
+    }
+
+    /**
+     * @module sdk/helpers
+     *
+     * @description
+     * Full config resolver for the TRI SDK. Lives in the **lazy chunk** — imported
+     * only after the `/collection-status` preflight succeeds. Transforms the
+     * host-supplied `TRIConfig` into a fully-defaulted `ResolvedTRIConfig`
+     * that all manager and collector instances consume.
+     */
+    /**
+     * Resolves the user-supplied `TRIConfig` into a complete, fully-defaulted internal
+     * config. Branches:
+     *  - no config / neither layers nor collectors → all collectors and events enabled,
+     *    no excludes (still honours `capture` and `profileId` when provided)
+     *  - layers map  → collectors enabled iff their layer is true; omitted layers = false
+     *  - collectors  → per-collector/per-event overrides; omitted collectors default to
+     *    **disabled** (host must explicitly opt-in each collector when supplying a
+     *    `collectors` map)
+     *
+     * `capture.element` defaults to `'redact'` — the PII-safe option. Hosts that want
+     * full element capture must explicitly set `capture: { element: 'all' }`.
+     */
+    function resolveTRIConfig(config) {
+        if (!config?.apiKey) {
+            logger.fatal('error', 'SDK', 'apiKey is required.');
+            return null;
+        }
+        let baseApiURL;
+        if (config.apiURL) {
+            if (!isApiURLSupported(config.apiURL)) {
+                logger.fatal('error', 'SDK', 'Provided apiURL is not supported:', config.apiURL, 'Supported API URLs are:', SUPPORTED_API_URLS.join(', '));
+                return null;
             }
-            const reportEventPayload = {
-                name,
-                metadata,
-                timestamp: Date.now(),
-                activityId: this.activityManager?.getActivityId() ?? ''
+            baseApiURL = config.apiURL;
+        }
+        else if (config.env) {
+            baseApiURL = resolveBaseApiURLFromEnv(config.env);
+        }
+        if (!baseApiURL) {
+            logger.fatal('error', 'SDK', "Couldn't initialise SDK — neither apiURL nor env were provided, or the provided value has no provisioned URL.");
+            return null;
+        }
+        const { element, content } = config.capture ?? {};
+        const sdk = {
+            capture: {
+                element: element ?? DEFAULT_CAPTURE_ELEMENT,
+                content: content ?? DEFAULT_CAPTURE_CONTENT
+            },
+            profileId: config.profileId,
+            api: {
+                key: config.apiKey,
+                version: config.apiVersion ?? DEFAULT_API_VERSION,
+                url: baseApiURL
+            },
+            sanitizeUrl: resolveSanitizeUrl(config.sanitizeUrl),
+            debug: config.debug ?? DEFAULT_DEBUG
+        };
+        if (config.collectors === undefined && config.layers === undefined) {
+            return { sdk, collectors: resolveDefaults() };
+        }
+        if (config.collectors !== undefined) {
+            return { sdk, collectors: resolveFromCollectors(config.collectors) };
+        }
+        return { sdk, collectors: resolveFromLayers(config.layers) };
+    }
+    /**
+     * Builds a ResolvedCollectorsConfig with every collector and event defaulting
+     * to enabled. Used when the host omits both `layers` and `collectors`.
+     */
+    function resolveDefaults() {
+        const result = {};
+        for (const key of COLLECTOR_KEYS) {
+            result[key] = resolveCollectorEntry(key, undefined, true);
+        }
+        return result;
+    }
+    /**
+     * Builds a ResolvedCollectorsConfig driven by a layer toggle map.
+     * Omitted layers default to `false` (all collectors in that layer disabled).
+     */
+    function resolveFromLayers(layers) {
+        const result = {};
+        for (const key of COLLECTOR_KEYS) {
+            const collectorEnabled = layers[COLLECTORS_CONFIG[key].layer] ?? false;
+            result[key] = resolveCollectorEntry(key, undefined, collectorEnabled);
+        }
+        return result;
+    }
+    /**
+     * Builds a ResolvedCollectorsConfig from a per-collector config object.
+     * Omitted collectors default to **disabled** — the host must explicitly set
+     * `enabled: true` for each collector it wants active when supplying a
+     * `collectors` map.
+     */
+    function resolveFromCollectors(collectorsInput) {
+        const result = {};
+        for (const key of COLLECTOR_KEYS) {
+            const input = collectorsInput[key];
+            const collectorEnabled = input?.enabled ?? false;
+            result[key] = resolveCollectorEntry(key, input, collectorEnabled);
+        }
+        return result;
+    }
+    /**
+     * Resolves a single collector entry into its fully typed ResolvedCollectorConfig.
+     * One `as` cast at the return boundary is intentional and sound: TypeScript cannot
+     * narrow a conditional type through a runtime length guard.
+     */
+    function resolveCollectorEntry(key, input, collectorEnabled) {
+        const eventNames = COLLECTORS_CONFIG[key]?.events ?? [];
+        if (eventNames.length === 0) {
+            return { enabled: collectorEnabled };
+        }
+        const eventsInput = input?.events;
+        const globalExcludes = eventsInput?.exclude ?? [];
+        const resolvedEvents = {};
+        for (const eventName of eventNames) {
+            const eventEntry = eventsInput?.[eventName];
+            resolvedEvents[eventName] = {
+                enabled: eventEntry?.enabled ?? true,
+                exclude: dedupe([...globalExcludes, ...(eventEntry?.exclude ?? [])])
             };
-            void this.falconServiceManager?.api.reportEvent(reportEventPayload);
-        }
-        _shouldEarlyEscapeInit() {
-            // TODO - more robust checks for document availability
-            if (this.initialized) {
-                {
-                    // eslint-disable-next-line no-console
-                    console.warn('[TriSDK] init() called more than once — ignoring.');
-                }
-                return true;
-            }
-            if (typeof document === 'undefined') {
-                // eslint-disable-next-line no-console
-                console.error('[TriSDK] init() called in a non-browser environment. The SDK will not start.');
-                return true;
-            }
-            return false;
         }
-        _shouldEarlyEscapeReportEvent() {
-            if (!this.initialized) {
-                {
-                    // eslint-disable-next-line no-console
-                    console.warn('[TriSDK] reportEvent() called before init() — event dropped.');
-                }
-                return true;
-            }
-            if (!this.activityManager) {
-                {
-                    // eslint-disable-next-line no-console
-                    console.warn('[TriSDK] activityManager not initialized.');
-                }
-                return true;
-            }
-            if (!this.transportManager) {
-                {
-                    // eslint-disable-next-line no-console
-                    console.warn('[TriSDK] transportManager not initialized.');
-                }
-                return true;
-            }
-            return false;
+        return {
+            enabled: collectorEnabled,
+            events: resolvedEvents
+        };
+    }
+    /**
+     * Returns a new array with duplicate values removed (preserves first occurrence).
+     */
+    function dedupe(array) {
+        return [...new Set(array)];
+    }
+    /**
+     * Produces the final `sanitizeUrl` function stored in the resolved SDK config.
+     * When the host supplies a hook, the hook receives both the raw URL and the
+     * default implementation so it can compose or replace as needed. Any exception
+     * thrown by the host hook is swallowed and the default is used as fallback,
+     * preserving the "zero impact on the host app" contract.
+     */
+    function resolveSanitizeUrl(hook) {
+        if (!hook)
+            return defaultSanitizeUrl;
+        return function sanitizeUrl(url) {
+            return (safeSync(() => hook(url, defaultSanitizeUrl)) ?? defaultSanitizeUrl(url));
+        };
+    }
+    /**
+     * Returns `true` when `apiURL` matches one of the provisioned base URLs from
+     * `ENV_TO_BASE_API_URL_LOOKUP`. Custom URLs not in the list are rejected.
+     */
+    function isApiURLSupported(apiURL) {
+        return SUPPORTED_API_URLS.includes(apiURL);
+    }
+
+    /**
+     * @module sdk/internal/start
+     *
+     * @description
+     * Heavy wiring module that is **dynamically imported** by `sdk.ts` after the
+     * `/collection-status` preflight succeeds.  Everything in this file — and every
+     * module it statically imports — lives in the lazy chunk.  Nothing in the static
+     * bundle references this file at runtime.
+     *
+     * Managers cross-reference each other through closures over local `let` variables.
+     * Each call to `start` creates a fresh scope, so repeated start/stop cycles
+     * each get independent manager instances.
+     *
+     * The function never throws: any failure during manager construction is caught,
+     * logged, and cleaned up internally; the caller receives `null` to signal failure.
+     *
+     * @internal
+     */
+    /**
+     * Resolves the raw host config and wires all manager instances, returning them
+     * as a struct.
+     *
+     * Called only when the `/collection-status` preflight returns `true`. The
+     * function never throws — if any step fails the partial state is cleaned up
+     * in reverse construction order and `null` is returned so the caller can
+     * reset cleanly.
+     *
+     * ### Construction order matters
+     * `FalconServiceManager` is constructed first because it holds the API client
+     * used by every other manager.  Its `getToken`, `refresh`, and `getActivityId`
+     * callbacks capture the `activityManagerRef` variable by closure — the variable
+     * is initially `null` and is assigned synchronously on the very next line, so
+     * by the time any callback is invoked (asynchronously) the ref is populated.
+     */
+    async function start(rawConfig) {
+        const resolvedConfig = resolveTRIConfig(rawConfig);
+        if (!resolvedConfig) {
+            logger.warn('SDK', 'start() failed: could not resolve config.');
+            return null;
         }
-        /* Manager Context Factories */
-        _createFalconServiceManagerContext(sdkConfig) {
-            return {
+        const { collectors: collectorsConfig, sdk: sdkConfig } = resolvedConfig;
+        // Local mutable manager references.  Context closures capture these variables,
+        // not the sdk fields, so they always see the current instance for this cycle.
+        let falconServiceManagerRef = null;
+        let activityManagerRef = null;
+        let transportManagerRef = null;
+        let tabManagerRef = null;
+        // Hoisted so the catch block can reach them for cleanup.
+        let lifecycleManager = null;
+        let collectorManager = null;
+        try {
+            /** Falcon Service Manager */
+            falconServiceManagerRef = createFalconServiceManager({
                 api: {
                     key: sdkConfig.api.key,
                     version: sdkConfig.api.version,
                     url: sdkConfig.api.url
                 },
                 profileId: sdkConfig.profileId,
-                getToken: () => this.activityManager?.getToken() ?? null,
-                refresh: async () => this.activityManager?.refresh() ?? Promise.resolve(),
-                getActivityId: () => this.activityManager?.getActivityId() ?? ''
-            };
-        }
-        _createActivityManagerContext() {
-            return {
-                startActivity: async () => this.falconServiceManager.api.startActivity(),
-                stopActivity: async () => this.falconServiceManager.api.stopActivity(),
+                getToken: () => activityManagerRef?.getToken() ?? null,
+                refresh: async () => activityManagerRef?.refresh() ?? Promise.resolve(),
+                getActivityId: () => activityManagerRef?.getActivityId() ?? ''
+            });
+            /** Activity Manager */
+            activityManagerRef = new ActivityManager({
+                startActivity: () => falconServiceManagerRef.api.startActivity(),
+                stopActivity: () => falconServiceManagerRef.api.stopActivity(),
                 db: ImmortalDB
-            };
-        }
-        _createTransportManagerContext() {
-            return {
-                ingest: async (payload, keepalive) => this.falconServiceManager.api.ingest(payload, keepalive),
-                getActivityId: () => this.activityManager.getActivityId(),
-                getTabId: () => this.tabManager?.getTabId() ?? 'unknown'
-            };
-        }
-        _createTabManagerContext() {
-            return {
-                push: (event) => this.transportManager?.push(event)
-            };
-        }
-        _createLifecycleManagerContext() {
+            });
+            await activityManagerRef.start();
+            /** Transport Manager */
+            transportManagerRef = new TransportManager(TRANSPORT_CONFIG, {
+                ingest: (payload, keepalive) => falconServiceManagerRef.api.ingest(payload, keepalive),
+                getTabId: () => tabManagerRef?.getTabId() ?? 'unknown'
+            });
+            transportManagerRef.start();
+            /** Tab Manager */
+            tabManagerRef = new TabManager({
+                push: (event) => transportManagerRef?.push(event)
+            });
+            await tabManagerRef.start();
+            /** Lifecycle Manager */
+            lifecycleManager = createLifecycleManager({
+                flush: () => transportManagerRef?.flush('lifecycle'),
+                stopActivity: async () => activityManagerRef?.stop(),
+                stopTab: () => tabManagerRef?.stop(),
+                getShouldSkipStopActivity: () => (tabManagerRef?.queryTabsNumber() ?? 0) > 1,
+                onConnectionChange: () => transportManagerRef?.onConnectionChange()
+            });
+            lifecycleManager.start();
+            /** Element Context Processor */
+            const elementContextProcessor = createElementContextProcessor(sdkConfig.capture?.element);
+            /** Collectors Manager */
+            const ignoredOrigins = new Set();
+            try {
+                ignoredOrigins.add(new URL(sdkConfig.api.url).origin);
+            }
+            catch {
+                // Malformed api.url — leave the set empty; no feedback-loop filtering.
+            }
+            collectorManager = createCollectorsManager({
+                push: (event) => transportManagerRef?.push(event),
+                resolveElement: (element) => elementContextProcessor.resolve(element),
+                sanitizeUrl: sdkConfig.sanitizeUrl,
+                ignoredOrigins: ignoredOrigins
+            }, collectorsConfig, sdkConfig.capture?.content);
+            collectorManager.autocapture();
+            /** Event Reporter */
+            const eventReportManager = new EventReportManager({
+                getActivityId: () => activityManagerRef?.getActivityId() ?? '',
+                reportEvent: (payload) => falconServiceManagerRef.api.reportEvent(payload)
+            });
             return {
-                flush: async () => this.transportManager?.flush('lifecycle'),
-                stopActivity: async () => this.activityManager?.stop(),
-                stopTab: () => this.tabManager?.stop(),
-                getShouldSkipStopActivity: async () => ((await this.tabManager?.queryTabsNumber()) ?? 0) <= 1,
-                releaseAliveLock: () => this.tabManager?.releaseAliveLock()
+                falconServiceManager: falconServiceManagerRef,
+                activityManager: activityManagerRef,
+                transportManager: transportManagerRef,
+                tabManager: tabManagerRef,
+                lifecycleManager,
+                collectorManager,
+                eventReportManager
             };
         }
-        _createCollectorsManagerContext(ecp, sdkConfig) {
-            return {
-                push: (event) => this.transportManager?.push(event),
-                resolveElement: (element) => ecp.resolve(element),
-                baseApiUrl: sdkConfig.api.url
-            };
+        catch (error) {
+            logger.warn('SDK', 'start() failed during manager wiring; tearing down partial state.', error);
+            // Best-effort cleanup in reverse construction order.
+            try {
+                lifecycleManager?.stop();
+            }
+            catch (e) {
+                logger.warn('SDK', 'lifecycleManager.stop() failed during teardown:', e);
+            }
+            try {
+                tabManagerRef?.stop();
+            }
+            catch (e) {
+                logger.warn('SDK', 'tabManager.stop() failed during teardown:', e);
+            }
+            try {
+                transportManagerRef?.stop();
+            }
+            catch (e) {
+                logger.warn('SDK', 'transportManager.stop() failed during teardown:', e);
+            }
+            try {
+                await activityManagerRef?.stop();
+            }
+            catch (e) {
+                logger.warn('SDK', 'activityManager.stop() failed during teardown:', e);
+            }
+            return null;
         }
-    };
+    }
 
-    const TriSDK = TriSDK$1.instance;
+    var start$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        start: start
+    });
 
-    return TriSDK;
+    return TRI;
 
 }));
 //# sourceMappingURL=tri.umd.js.map