@corbado/observe 1.10.0 → 1.11.0

package/dist/analysis/config.mjs

@@ -183,13 +183,10 @@ function resolveFixedDataConfig(raw) {
       return void 0;
     }
     const value = raw;
-    const pmd = value.pmd;
-    const pmdExplicit = typeof pmd === "boolean";
     const crossOrigin = value.crossOriginSession;
     const cookieDomain = crossOrigin && typeof crossOrigin === "object" && typeof crossOrigin.cookieDomain === "string" ? crossOrigin.cookieDomain : void 0;
     return {
-      pmd: pmdExplicit ? pmd : false,
-      pmdExplicit,
+      pmd: asBoolean(value.pmd, false),
       privateMode: asBoolean(value.privateMode, true),
       ...cookieDomain !== void 0 && { crossOriginSession: { cookieDomain } }
     };

package/dist/analysis/default-tracker.mjs

@@ -0,0 +1,16 @@
+// src/default-tracker.ts
+var current;
+function setDefaultTracker(tracker) {
+  current = tracker;
+}
+function getDefaultTracker() {
+  return current;
+}
+function isTracker(value) {
+  return !!value && typeof value === "object" && typeof value.track === "function" && typeof value.enqueueLowEvent === "function";
+}
+export {
+  getDefaultTracker,
+  isTracker,
+  setDefaultTracker
+};

package/dist/analysis/device.mjs

@@ -7,7 +7,6 @@ import {
   readConditionalMediationAvailable,
   readJavaScriptHighEntropy,
   readMaxTouchPoints,
-  readUserAgent,
   readUserVerifyingPlatformAuthenticatorAvailable,
   readWebdriver
 } from "./readers/device.mjs";
@@ -515,84 +514,6 @@ var DeviceCollector = class {
       this.logger.error("Failed to report device info timing", error);
     }
   }
-  /**
-   * Error situations:
-   *  - navigator is not available: user agent is treated as empty, osName and browserName are "other"
-   *  - navigator is available but userAgent is null or undefined: same as above
-   */
-  static getOsAndBrowserInfo() {
-    return {
-      osName: this.getOsName(),
-      browserName: this.getBrowserName()
-    };
-  }
-  static getUserAgent() {
-    return readUserAgent({
-      key: "browser-api:device.user-agent",
-      title: "Browser and operating system",
-      accessNote: "navigator.userAgent",
-      group: "Device information",
-      origin: "observe-external",
-      fields: [
-        {
-          path: "result",
-          label: "Browser and operating system",
-          exposure: "class",
-          transform: {
-            classes: [
-              "iOS",
-              "Android",
-              "Windows",
-              "macOS",
-              "Linux",
-              "ChromeOS",
-              "Chrome",
-              "Firefox",
-              "Safari",
-              "Edge",
-              "Opera",
-              "IE",
-              "other"
-            ]
-          }
-        }
-      ]
-    });
-  }
-  static getOsName() {
-    const ua = this.getUserAgent();
-    if (ua.includes("iOS")) {
-      return "iOS";
-    } else if (ua.includes("Android")) {
-      return "Android";
-    } else if (ua.includes("Windows")) {
-      return "Windows";
-    } else if (ua.includes("Macintosh")) {
-      return "macOS";
-    } else if (ua.includes("Linux")) {
-      return "Linux";
-    } else if (ua.includes("ChromeOS")) {
-      return "ChromeOS";
-    }
-    return "other";
-  }
-  static getBrowserName() {
-    const ua = this.getUserAgent();
-    if (ua.includes("Chrome")) {
-      return "Chrome";
-    } else if (ua.includes("Firefox")) {
-      return "Firefox";
-    } else if (ua.includes("Safari")) {
-      return "Safari";
-    } else if (ua.includes("Edge")) {
-      return "Edge";
-    } else if (ua.includes("Opera")) {
-      return "Opera";
-    } else if (ua.includes("IE")) {
-      return "IE";
-    }
-    return "other";
-  }
   getClientEnvHandle() {
     const existingClientEnvHandle = this.storage.getItem("cbo_client_env_handle");
     if (existingClientEnvHandle) {

package/dist/analysis/index.mjs

@@ -1,8 +1,17 @@
 // src/index.ts
 import { CorbadoTracker } from "./client.mjs";
+import { CorbadoTrackerCore } from "./tracker-core.mjs";
+import { getDefaultTracker, setDefaultTracker } from "./default-tracker.mjs";
 import { SDK_NAME, SDK_VERSION } from "./version.mjs";
 export * from "./types.mjs";
 export * from "./client.mjs";
+export * from "./tracker-core.mjs";
+export * from "./tracker-functions.mjs";
+export * from "./plugins/cookie-storage.mjs";
+export * from "./plugins/cross-origin-session.mjs";
+export * from "./plugins/raw-errors.mjs";
+export * from "./plugins/probes.mjs";
+export * from "./probe-lane.mjs";
 export * from "./transport.mjs";
 export * from "./queue.mjs";
 export * from "./config.mjs";
@@ -41,78 +50,57 @@ import {
   sanitizeRequestOptions,
   sanitizeAssertionResponse
 } from "./utils/webauthn-payloads.mjs";
-var currentTracker;
 function init(options) {
   const tracker = new CorbadoTracker(options);
-  currentTracker = tracker;
+  setDefaultTracker(tracker);
+  return tracker;
+}
+function initCore(options) {
+  const tracker = new CorbadoTrackerCore(options);
+  setDefaultTracker(tracker);
   return tracker;
 }
 function getTracker() {
-  return currentTracker;
+  const tracker = getDefaultTracker();
+  return tracker?.isFullTracker() ? tracker : void 0;
 }
-function resetSession() {
-  return currentTracker?.resetSession();
+function getTrackerCore() {
+  return getDefaultTracker();
 }
 function getSessionId() {
-  return currentTracker?.getSessionId();
-}
-function setUser(user) {
-  currentTracker?.setUser(user);
-}
-function setFlowTags(tags, options) {
-  currentTracker?.setFlowTags(tags, options);
-}
-function setExperiment(key, variant) {
-  currentTracker?.setExperiment(key, variant);
+  return getDefaultTracker()?.getSessionId();
 }
 function setExperiments(assignments) {
-  currentTracker?.setExperiments(assignments);
-}
-function clearExperiment(key) {
-  currentTracker?.clearExperiment(key);
-}
-function clearExperiments() {
-  currentTracker?.clearExperiments();
+  getDefaultTracker()?.setExperiments(assignments);
 }
 function getExperiments() {
-  return currentTracker?.getExperiments() ?? {};
+  return getDefaultTracker()?.getExperiments() ?? {};
 }
 function telemetry(level, message) {
-  currentTracker?.telemetry(level, message);
-}
-function logInfo(message) {
-  currentTracker?.logInfo(message);
-}
-function logError(message) {
-  currentTracker?.logError(message);
+  getDefaultTracker()?.telemetry(level, message);
 }
 async function destroy() {
-  if (!currentTracker) return;
-  await currentTracker.destroy();
-  currentTracker = void 0;
+  const tracker = getDefaultTracker();
+  if (!tracker) return;
+  await tracker.destroy();
+  setDefaultTracker(void 0);
 }
 export {
   READER_EXPOSURES,
   SDK_NAME,
   SDK_VERSION,
-  clearExperiment,
-  clearExperiments,
   destroy,
   detectPasswordManagerExtensions,
   getExperiments,
   getSessionId,
   getTracker,
+  getTrackerCore,
   init,
-  logError,
-  logInfo,
-  resetSession,
+  initCore,
   sanitizeAssertionResponse,
   sanitizeCreationOptions,
   sanitizeCreationResponse,
   sanitizeRequestOptions,
-  setExperiment,
   setExperiments,
-  setFlowTags,
-  setUser,
   telemetry
 };

package/dist/analysis/low-events/grouped-input-tracker.mjs

@@ -99,7 +99,7 @@ var LowEventGroupedInputTracker = class {
               this.composing ||= composing;
               if (this.changeTimer !== null) return;
               this.changeTime = Date.now();
-              this.changeSeq = sink.reserveCaptureSeq?.();
+              this.changes.observe();
               this.changeTimer = setTimeout(() => this.safe(() => this.flushChanges()), 0);
             },
             focus: (relatedTarget) => {
@@ -174,7 +174,6 @@ var LowEventGroupedInputTracker = class {
   listeners = [];
   changeTimer = null;
   changeTime = 0;
-  changeSeq;
   composing = false;
   destroyed = false;
   contains(target) {
@@ -214,7 +213,7 @@ var LowEventGroupedInputTracker = class {
   flushChanges() {
     if (this.changeTimer === null) return;
     this.cancelChange();
-    if (!this.paste.pending) this.changes.record(this.length(), this.changeTime, this.composing, this.changeSeq);
+    if (!this.paste.pending) this.changes.record(this.length(), this.changeTime, this.composing);
     this.composing = false;
   }
   emit(lowType) {

package/dist/analysis/low-events/input-change-recorder.mjs

@@ -18,9 +18,28 @@ var InputChangeRecorder = class {
   autofillTimestamps = [];
   autofillStreak = null;
   idleTimer = null;
+  /** Order of the pending run of changes: reserved when it starts, taken by the first event it sends. */
+  runSeq;
   markInputObserved() {
     this.prefillSettled = true;
   }
+  /**
+   * Observation of a change begins: reserves the capture order of a new run of changes. One number per
+   * run, not per change: every reserved number is sent, so the gaps between sent events never count
+   * keystrokes (which would reveal the length of the typed value).
+   */
+  observe() {
+    if (this.runSeq !== void 0 || this.inputBatch || this.autofillTimestamps.length > 0 || this.autofillStreak) {
+      return;
+    }
+    this.runSeq = this.reserveCaptureSeq?.();
+  }
+  /** The run's reserved order for its first event; later events of the run reserve when they are created. */
+  takeSeq() {
+    const seq = this.runSeq;
+    this.runSeq = void 0;
+    return seq ?? this.reserveCaptureSeq?.();
+  }
   capturePrefill(length, newCapture = false) {
     if (newCapture) this.prefillSettled = false;
     if (this.prefillSettled) return;
@@ -50,17 +69,17 @@ var InputChangeRecorder = class {
       }
     }, INPUT_IDLE_MS);
   }
-  extendInputBatch(timestamp, effect = this.currentEffect, captureSeq) {
+  extendInputBatch(timestamp, effect = this.currentEffect) {
     const batch = this.inputBatch;
     if (!batch) {
-      this.inputBatch = { firstTimestamp: timestamp, lastTimestamp: timestamp, effect, captureSeq };
+      this.inputBatch = { firstTimestamp: timestamp, lastTimestamp: timestamp, effect, captureSeq: this.takeSeq() };
       return;
     }
     batch.lastTimestamp = timestamp;
   }
   drainAutofillRingToBatch() {
     for (const ts of this.autofillTimestamps) {
-      this.extendInputBatch(ts.ts, this.ringEffect, ts.captureSeq);
+      this.extendInputBatch(ts, this.ringEffect);
     }
     this.autofillTimestamps.length = 0;
   }
@@ -101,7 +120,7 @@ var InputChangeRecorder = class {
     let minInterval = Infinity;
     let maxInterval = -Infinity;
     for (let i = 1; i < ring.length; i++) {
-      const interval = ring[i].ts - ring[i - 1].ts;
+      const interval = ring[i] - ring[i - 1];
       if (interval > AUTOFILL_FAST_INTERVAL_MS) {
         return false;
       }
@@ -114,7 +133,8 @@ var InputChangeRecorder = class {
     }
     return maxInterval - minInterval <= AUTOFILL_UNIFORM_SPREAD_MS;
   }
-  record(newLength, timestamp = Date.now(), composing = false, captureSeq = this.reserveCaptureSeq?.()) {
+  record(newLength, timestamp = Date.now(), composing = false) {
+    this.observe();
     this.markInputObserved();
     this.scheduleIdle();
     const oldLength = this.previousLength;
@@ -123,6 +143,7 @@ var InputChangeRecorder = class {
     this.previousLength = newLength;
     if (newLength === 0 && oldLength > 0) {
       this.flush();
+      const captureSeq = this.takeSeq();
       this.pushLow({
         ...captureSeq === void 0 ? {} : { captureSeq },
         lowType: "input-clear",
@@ -134,12 +155,13 @@ var InputChangeRecorder = class {
     if (composing) {
       this.flushAutofillStreak();
       this.drainAutofillRingToBatch();
-      this.extendInputBatch(timestamp, this.currentEffect, captureSeq);
+      this.extendInputBatch(timestamp, this.currentEffect);
       return;
     }
     if (delta >= BIG_INPUT_DELTA_THRESHOLD) {
       this.flushInputBatch();
       this.flushAutofillStreak();
+      const captureSeq = this.takeSeq();
       this.pushLow({
         ...captureSeq === void 0 ? {} : { captureSeq },
         lowType: "big-input-add",
@@ -151,6 +173,7 @@ var InputChangeRecorder = class {
     if (delta <= -BIG_INPUT_DELTA_THRESHOLD) {
       this.flushInputBatch();
       this.flushAutofillStreak();
+      const captureSeq = this.takeSeq();
       this.pushLow({
         ...captureSeq === void 0 ? {} : { captureSeq },
         lowType: "big-input-rem",
@@ -169,15 +192,15 @@ var InputChangeRecorder = class {
     }
     if (delta !== 1) {
       this.drainAutofillRingToBatch();
-      this.extendInputBatch(timestamp, this.currentEffect, captureSeq);
+      this.extendInputBatch(timestamp, this.currentEffect);
       return;
     }
     const ring = this.autofillTimestamps;
     if (ring.length === 0) this.ringEffect = this.currentEffect;
-    ring.push({ ts: timestamp, captureSeq });
+    ring.push(timestamp);
     if (ring.length > AUTOFILL_STREAK_LENGTH) {
       const graduated = ring.shift();
-      this.extendInputBatch(graduated.ts, this.ringEffect, graduated.captureSeq);
+      this.extendInputBatch(graduated, this.ringEffect);
       this.ringEffect = "modify";
     }
     if (!this.detectAutofillStreak()) {
@@ -188,9 +211,9 @@ var InputChangeRecorder = class {
     ring.length = 0;
     this.flushInputBatch();
     this.autofillStreak = {
-      firstTimestamp: streakStart.ts,
-      captureSeq: streakStart.captureSeq,
-      lastTimestamp: streakLast.ts,
+      firstTimestamp: streakStart,
+      captureSeq: this.takeSeq(),
+      lastTimestamp: streakLast,
       effect: this.ringEffect
     };
   }

package/dist/analysis/low-events/input-tracker.mjs

@@ -3,9 +3,6 @@ import { InputChangeRecorder } from "./input-change-recorder.mjs";
 import { InputPasteObserver } from "../readers/input-paste.mjs";
 import { observeInputField, readFocusedField, readInputContentLength } from "../readers/input.mjs";
 import { listenWindow } from "../readers/page.mjs";
-import { readPasswordManagerDomSignals } from "../readers/password-manager-dom.mjs";
-var MOUNT_PROBE_DELAY_MS = 500;
-var FOCUS_PROBE_DELAY_MS = 250;
 function fieldContentLength(field) {
   return readInputContentLength(
     {
@@ -85,10 +82,6 @@ var LowEventInputTracker = class {
   removePageHide;
   changes;
   pasteObserver;
-  emittedSignals = /* @__PURE__ */ new Set();
-  firstFocusHandled = false;
-  mountProbeTimer = null;
-  focusProbeTimer = null;
   destroyed = false;
   destroy() {
     if (this.destroyed) {
@@ -96,14 +89,6 @@ var LowEventInputTracker = class {
     }
     this.destroyed = true;
     try {
-      if (this.mountProbeTimer !== null) {
-        clearTimeout(this.mountProbeTimer);
-        this.mountProbeTimer = null;
-      }
-      if (this.focusProbeTimer !== null) {
-        clearTimeout(this.focusProbeTimer);
-        this.focusProbeTimer = null;
-      }
       this.changes.flush();
       this.unregisterInputs?.();
       this.pasteObserver.destroy();
@@ -204,9 +189,6 @@ var LowEventInputTracker = class {
         this.handleFocus();
       }
     }
-    if (typeof window !== "undefined") {
-      this.mountProbeTimer = setTimeout(() => this.runEnvProbe(), MOUNT_PROBE_DELAY_MS);
-    }
   }
   detach() {
     this.removeFieldListeners?.();
@@ -217,45 +199,6 @@ var LowEventInputTracker = class {
   pushLow = (low) => {
     this.sink.enqueueLowEvent(low);
   };
-  runEnvProbe() {
-    try {
-      if (typeof __CBO_DATA_PMD__ === "boolean" ? __CBO_DATA_PMD__ : this.sink.passwordManagerDomScan?.() !== false) {
-        const matches = readPasswordManagerDomSignals({
-          key: "dom:password-managers.dom-signals",
-          title: "Password manager traces in the page",
-          accessNote: "DOM markers that password manager extensions insert (attributes, elements, styles)",
-          group: "Password manager detection",
-          origin: "observe-external",
-          fields: [
-            {
-              path: "signals[]",
-              label: "Password manager traces found",
-              exposure: "enum",
-              transform: { values: ["pa-1", "pa-2", "pa-3", "pa-4", "pa-5", "pa-6"] }
-            }
-          ],
-          dataConfig: "pmd"
-        });
-        const now = Date.now();
-        for (const eventType of matches) {
-          if (this.emittedSignals.has(eventType)) {
-            continue;
-          }
-          this.emittedSignals.add(eventType);
-          this.pushLow({ lowType: eventType, ts: now });
-        }
-      }
-    } catch (error) {
-      this.logger.error("Failed to run input env probe", error);
-    }
-  }
-  scheduleFocusProbe() {
-    if (this.firstFocusHandled) {
-      return;
-    }
-    this.firstFocusHandled = true;
-    this.focusProbeTimer = setTimeout(() => this.runEnvProbe(), FOCUS_PROBE_DELAY_MS);
-  }
   capturePrefill(newCapture = false) {
     if (this.destroyed) return;
     this.flushPending();
@@ -270,7 +213,6 @@ var LowEventInputTracker = class {
     this.pushLow({ lowType: eventType, ts: Date.now() });
   }
   handleFocus() {
-    this.scheduleFocusProbe();
     this.enqueueNonInputEvent("focus");
   }
   handleBlur() {

package/dist/analysis/plugins/cookie-storage.mjs

@@ -0,0 +1,11 @@
+// src/plugins/cookie-storage.ts
+import { CookieStorage } from "../storage/index.mjs";
+function cookieStorage(options = {}) {
+  const cookieDomain = options?.cookieDomain;
+  return {
+    storage: (logger) => ({ engine: new CookieStorage(logger, cookieDomain), source: "cookie" })
+  };
+}
+export {
+  cookieStorage
+};

package/dist/analysis/plugins/cross-origin-session.mjs

@@ -0,0 +1,171 @@
+// src/plugins/cross-origin-session.ts
+import { CrossOriginSession, isValidCrossOriginContext } from "../cross-origin-session.mjs";
+import {
+  SEQ_STORAGE_KEY,
+  SESSION_CONTINUITY_KEY,
+  SESSION_STORAGE_KEY
+} from "../session-keys.mjs";
+function crossOriginSession(config) {
+  const cookieDomain = config && typeof config === "object" ? config.cookieDomain : void 0;
+  return {
+    session: (tracker) => typeof cookieDomain === "string" ? CrossOriginBridge.create(tracker, cookieDomain) : void 0
+  };
+}
+var CrossOriginBridge = class _CrossOriginBridge {
+  constructor(tracker, cookie) {
+    this.tracker = tracker;
+    this.cookie = cookie;
+  }
+  /** The session this load took from the cross-origin cookie, if any (`meta.crossOriginSession`). */
+  adoptedId;
+  /** The bridge when the cookie is usable here; undefined (feature off) otherwise. Never throws. */
+  static create(tracker, cookieDomain) {
+    try {
+      if (tracker["isTrackingBlocked"]()) {
+        return void 0;
+      }
+      const cookie = CrossOriginSession.create({
+        projectId: tracker["options"].projectId,
+        cookieDomain,
+        logger: tracker.getLogger(),
+        inactivityMs: () => tracker["config"].sessionInactivityMs,
+        report: (level, message) => tracker["reportTelemetry"](level, message)
+      });
+      return cookie ? new _CrossOriginBridge(tracker, cookie) : void 0;
+    } catch (error) {
+      tracker.getLogger().error("Failed to set up the cross-origin session", error);
+      return void 0;
+    }
+  }
+  resolve() {
+    const tracker = this.tracker;
+    const localActivity = this.readLocalSessionActivity();
+    tracker["sessionId"] = tracker["resolveSessionId"]();
+    this.boot(localActivity);
+    return tracker["sessionId"];
+  }
+  claim(sessionId, seq, now) {
+    return this.cookie.claim(sessionId, seq, now);
+  }
+  /** `meta.crossOriginSession` of a batch of `sessionId`; undefined while the cookie is off on this page. */
+  meta(sessionId) {
+    if (!this.cookie.isEnabled()) {
+      return void 0;
+    }
+    return sessionId && sessionId === this.adoptedId ? "adopted" : "own";
+  }
+  reset(sessionId) {
+    this.cookie.reset(sessionId);
+  }
+  stop() {
+    this.cookie.stop();
+  }
+  /** The seq the tracker continues from (persisted counter under continuity). */
+  localSeq() {
+    const tracker = this.tracker;
+    return tracker["config"].sessionContinuity ? Math.max(tracker["seq"], tracker["persistentStorage"].getItem(SEQ_STORAGE_KEY) ?? 0) : tracker["seq"];
+  }
+  /**
+   * Last activity of the local session records BEFORE this load rewrites them (both paths, by id), so the
+   * cross-origin boot can tell a session that was active here from one this load just created.
+   */
+  readLocalSessionActivity() {
+    const tracker = this.tracker;
+    const activity = /* @__PURE__ */ new Map();
+    try {
+      const continuity = tracker["persistentStorage"].getItem(SESSION_CONTINUITY_KEY);
+      if (continuity?.id && typeof continuity.lastActiveAt === "number") {
+        activity.set(continuity.id, continuity.lastActiveAt);
+      }
+      const perTab = tracker["sessionStorage"].getItem(SESSION_STORAGE_KEY);
+      if (perTab && typeof perTab === "object" && perTab.id && typeof perTab.lastActiveAt === "number") {
+        activity.set(perTab.id, Math.max(activity.get(perTab.id) ?? 0, perTab.lastActiveAt));
+      }
+    } catch (error) {
+      tracker.getLogger().error("Failed to read local session activity", error);
+    }
+    return activity;
+  }
+  /**
+   * Reconcile the session this load resolved locally with the cross-origin cookie before the first event:
+   * adopt the cookie's session (and persist it locally, so reloads and same-origin tabs follow) or keep
+   * the local one, and continue the seq at or above the cookie's mark. Never throws.
+   */
+  boot(localActivity) {
+    const tracker = this.tracker;
+    try {
+      this.adoptedId = void 0;
+      const now = Date.now();
+      const continuity = tracker["config"].sessionContinuity;
+      const sessionId = tracker["sessionId"];
+      const result = this.cookie.boot(
+        {
+          sessionId,
+          lastActiveAt: sessionId && localActivity.get(sessionId) || 0,
+          seq: this.localSeq()
+        },
+        now
+      );
+      if (!result || !result.sessionId) {
+        return;
+      }
+      if (result.adopted) {
+        tracker["sessionId"] = result.sessionId;
+        this.adoptedId = result.sessionId;
+        if (continuity) {
+          tracker["persistContinuitySession"](result.sessionId, now);
+        } else {
+          tracker["persistPerTabSession"](result.sessionId, now);
+        }
+        tracker.getLogger().debug("Adopted cross-origin session id", result.sessionId);
+      }
+      tracker["seq"] = result.seq;
+      if (continuity) {
+        tracker["persistentStorage"].setItem(SEQ_STORAGE_KEY, result.seq);
+      }
+    } catch (error) {
+      tracker.getLogger().error("Failed to apply the cross-origin session", error);
+    }
+  }
+};
+function setCrossOriginContext(tracker, context) {
+  try {
+    const bridge = tracker["bridge"];
+    if (!(bridge instanceof CrossOriginBridge)) {
+      return false;
+    }
+    const value = context === null || context === void 0 || context === "" ? void 0 : context;
+    if (value !== void 0 && !isValidCrossOriginContext(value)) {
+      tracker.getLogger().debug("Ignoring invalid cross-origin context (expected <= 128 chars of [A-Za-z0-9._~-])");
+      return false;
+    }
+    const next = bridge.cookie.setContext(tracker["sessionId"], bridge.localSeq(), value);
+    if (next === void 0) {
+      return false;
+    }
+    if (next > tracker["seq"]) {
+      tracker["seq"] = next;
+      if (tracker["config"].sessionContinuity) {
+        tracker["persistentStorage"].setItem(SEQ_STORAGE_KEY, next);
+      }
+    }
+    return true;
+  } catch (error) {
+    tracker.getLogger().error("Failed to set the cross-origin context", error);
+    return false;
+  }
+}
+function getCrossOriginContext(tracker) {
+  try {
+    const bridge = tracker["bridge"];
+    return bridge instanceof CrossOriginBridge ? bridge.cookie.getContext(tracker["sessionId"]) : void 0;
+  } catch (error) {
+    tracker.getLogger().error("Failed to read the cross-origin context", error);
+    return void 0;
+  }
+}
+export {
+  crossOriginSession,
+  getCrossOriginContext,
+  setCrossOriginContext
+};