@pratham.raval/browser-core 6.22.3 → 6.22.4

package/src/domain/intakeSites.ts

@@ -1,17 +1,2 @@
-export type Site =
-  | 'datadoghq.com'
-  | 'us3.datadoghq.com'
-  | 'us5.datadoghq.com'
-  | 'datadoghq.eu'
-  | 'ddog-gov.com'
-  | 'ap1.datadoghq.com'
-  | 'ap2.datadoghq.com'
-
-export const INTAKE_SITE_STAGING: Site = 'datad0g.com' as Site
-export const INTAKE_SITE_FED_STAGING: Site = 'dd0g-gov.com' as Site
-export const INTAKE_SITE_US1: Site = 'datadoghq.com'
-export const INTAKE_SITE_EU1: Site = 'datadoghq.eu'
-export const INTAKE_SITE_US1_FED: Site = 'ddog-gov.com'
-
-export const PCI_INTAKE_HOST_US1 = 'pci.browser-intake-datadoghq.com'
-export const INTAKE_URL_PARAMETERS = ['ddsource', 'dd-api-key', 'dd-request-id']
+export type Site = string
+export const INTAKE_URL_PARAMETERS = ['mdsource', 'md-api-key', 'md-request-id']

package/src/domain/session/oldCookiesMigration.ts

@@ -4,7 +4,7 @@ import { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'
 import type { SessionState } from './sessionState'
 import { expandSessionState, isSessionStarted } from './sessionState'
 
-export const OLD_SESSION_COOKIE_NAME = '_dd'
+export const OLD_SESSION_COOKIE_NAME = '_md'
 export const OLD_RUM_COOKIE_NAME = '_dd_r'
 export const OLD_LOGS_COOKIE_NAME = '_dd_l'
 

package/src/domain/session/sessionManager.ts

@@ -14,12 +14,13 @@ import { getCurrentSite } from '../../browser/cookie'
 import { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures'
 import { findLast } from '../../tools/utils/polyfills'
 import { monitorError } from '../../tools/monitor'
-import { SESSION_NOT_TRACKED, SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { SESSION_NOT_TRACKED, SESSION_TIME_OUT_DELAY, SessionPersistence } from './sessionConstants'
 import { startSessionStore } from './sessionStore'
 import type { SessionState } from './sessionState'
 import { toSessionState } from './sessionState'
 import { retrieveSessionCookie } from './storeStrategies/sessionInCookie'
 import { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'
+import { retrieveSessionFromLocalStorage } from './storeStrategies/sessionInLocalStorage'
 
 export interface SessionManager<TrackingType extends string> {
   findSession: (
@@ -38,6 +39,7 @@ export interface SessionContext<TrackingType extends string> extends Context {
   trackingType: TrackingType
   isReplayForced: boolean
   anonymousId: string | undefined
+  created: string | undefined
 }
 
 export const VISIBILITY_CHECK_DELAY = ONE_MINUTE
@@ -91,7 +93,7 @@ export function startSessionManager<TrackingType extends string>(
     if (trackingConsentState.isGranted()) {
       sessionStore.expandOrRenewSession()
     } else {
-      sessionStore.expire()
+      sessionStore.expire(false)
     }
   })
 
@@ -107,13 +109,14 @@ export function startSessionManager<TrackingType extends string>(
     const session = sessionStore.getSession()
 
     if (!session) {
-      reportUnexpectedSessionState().catch(() => void 0) // Ignore errors
+      reportUnexpectedSessionState(configuration).catch(() => void 0) // Ignore errors
 
       return {
         id: 'invalid',
         trackingType: SESSION_NOT_TRACKED as TrackingType,
         isReplayForced: false,
         anonymousId: undefined,
+        created: undefined,
       }
     }
 
@@ -122,6 +125,7 @@ export function startSessionManager<TrackingType extends string>(
       trackingType: session[productKey] as TrackingType,
       isReplayForced: !!session.forcedReplay,
       anonymousId: session.anonymousId,
+      created: session.created,
     }
   }
 
@@ -172,16 +176,33 @@ function trackResume(configuration: Configuration, cb: () => void) {
   stopCallbacks.push(stop)
 }
 
-async function reportUnexpectedSessionState() {
-  const rawSession = retrieveSessionCookie()
+async function reportUnexpectedSessionState(configuration: Configuration) {
+  const sessionStoreStrategyType = configuration.sessionStoreStrategyType
+  if (!sessionStoreStrategyType) {
+    return
+  }
+
+  let rawSession
+  let cookieContext
+
+  if (sessionStoreStrategyType.type === SessionPersistence.COOKIE) {
+    rawSession = retrieveSessionCookie(sessionStoreStrategyType.cookieOptions)
+
+    cookieContext = {
+      cookie: await getSessionCookies(),
+      currentDomain: `${window.location.protocol}//${window.location.hostname}`,
+    }
+  } else {
+    rawSession = retrieveSessionFromLocalStorage()
+  }
   // monitor-until: forever, could be handy to troubleshoot issues until session manager rework
   addTelemetryDebug('Unexpected session state', {
+    sessionStoreStrategyType: sessionStoreStrategyType.type,
     session: rawSession,
     isSyntheticsTest: isSyntheticsTest(),
     createdTimestamp: rawSession?.created,
     expireTimestamp: rawSession?.expire,
-    cookie: await getSessionCookies(),
-    currentDomain: `${window.location.protocol}//${window.location.hostname}`,
+    ...cookieContext,
   })
 }
 

package/src/domain/session/sessionState.ts

@@ -1,7 +1,6 @@
 import { isEmptyObject } from '../../tools/utils/objectUtils'
 import { objectEntries } from '../../tools/utils/polyfills'
 import { dateNow } from '../../tools/utils/timeUtils'
-import { generateUUID } from '../../tools/utils/stringUtils'
 import type { Configuration } from '../configuration'
 import { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants'
 import { isValidSessionString, SESSION_ENTRY_REGEXP, SESSION_ENTRY_SEPARATOR } from './sessionStateValidation'
@@ -23,12 +22,8 @@ export function getExpiredSessionState(
   const expiredSessionState: SessionState = {
     isExpired: EXPIRED,
   }
-  if (configuration.trackAnonymousUser) {
-    if (previousSessionState?.anonymousId) {
-      expiredSessionState.anonymousId = previousSessionState?.anonymousId
-    } else {
-      expiredSessionState.anonymousId = generateUUID()
-    }
+  if (configuration.trackAnonymousUser && previousSessionState?.anonymousId) {
+    expiredSessionState.anonymousId = previousSessionState?.anonymousId
   }
   return expiredSessionState
 }

package/src/domain/session/sessionStore.ts

@@ -26,7 +26,7 @@ export interface SessionStore {
   renewObservable: Observable<void>
   expireObservable: Observable<void>
   sessionStateUpdateObservable: Observable<{ previousState: SessionState; newState: SessionState }>
-  expire: () => void
+  expire: (hasConsent?: boolean) => void
   stop: () => void
   updateSessionState: (state: Partial<SessionState>) => void
 }
@@ -170,6 +170,7 @@ export function startSessionStore<TrackingType extends string>(
       {
         process: (sessionState) => {
           if (isSessionInNotStartedState(sessionState)) {
+            sessionState.anonymousId = generateUUID()
             return getExpiredSessionState(sessionState, configuration)
           }
         },
@@ -231,8 +232,11 @@ export function startSessionStore<TrackingType extends string>(
     expireObservable,
     sessionStateUpdateObservable,
     restartSession: startSession,
-    expire: () => {
+    expire: (hasConsent?: boolean) => {
       cancelExpandOrRenewSession()
+      if (hasConsent === false && sessionCache) {
+        delete sessionCache.anonymousId
+      }
       sessionStoreStrategy.expireSession(sessionCache)
       synchronizeSession(getExpiredSessionState(sessionCache, configuration))
     },

package/src/domain/session/storeStrategies/sessionInCookie.ts

@@ -1,6 +1,8 @@
+import { isExperimentalFeatureEnabled, ExperimentalFeature } from '../../../tools/experimentalFeatures'
+import { isEmptyObject } from '../../../tools/utils/objectUtils'
 import { isChromium } from '../../../tools/utils/browserDetection'
 import type { CookieOptions } from '../../../browser/cookie'
-import { getCurrentSite, areCookiesAuthorized, getCookie, setCookie } from '../../../browser/cookie'
+import { getCurrentSite, areCookiesAuthorized, getCookies, setCookie, getCookie } from '../../../browser/cookie'
 import type { InitConfiguration, Configuration } from '../../configuration'
 import { tryOldCookiesMigration } from '../oldCookiesMigration'
 import {
@@ -14,6 +16,8 @@ import { toSessionString, toSessionState, getExpiredSessionState } from '../sess
 import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
 import { SESSION_STORE_KEY } from './sessionStoreStrategy'
 
+const SESSION_COOKIE_VERSION = 0
+
 export function selectCookieStrategy(initConfiguration: InitConfiguration): SessionStoreStrategyType | undefined {
   const cookieOptions = buildCookieOptions(initConfiguration)
   return cookieOptions && areCookiesAuthorized(cookieOptions)
@@ -30,7 +34,7 @@ export function initCookieStrategy(configuration: Configuration, cookieOptions:
     isLockEnabled: isChromium(),
     persistSession: (sessionState: SessionState) =>
       storeSessionCookie(cookieOptions, configuration, sessionState, SESSION_EXPIRATION_DELAY),
-    retrieveSession: retrieveSessionCookie,
+    retrieveSession: () => retrieveSessionCookie(cookieOptions),
     expireSession: (sessionState: SessionState) =>
       storeSessionCookie(
         cookieOptions,
@@ -51,15 +55,34 @@ function storeSessionCookie(
   sessionState: SessionState,
   defaultTimeout: number
 ) {
+  let sessionStateString = toSessionString(sessionState)
+
+  if (isExperimentalFeatureEnabled(ExperimentalFeature.ENCODE_COOKIE_OPTIONS)) {
+    sessionStateString = toSessionString({
+      ...sessionState,
+      // deleting a cookie is writing a new cookie with an empty value
+      // we don't want to store the cookie options in this case otherwise the cookie will not be deleted
+      ...(!isEmptyObject(sessionState) ? { c: encodeCookieOptions(options) } : {}),
+    })
+  }
+
   setCookie(
     SESSION_STORE_KEY,
-    toSessionString(sessionState),
+    sessionStateString,
     configuration.trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : defaultTimeout,
     options
   )
 }
 
-export function retrieveSessionCookie(): SessionState {
+/**
+ * Retrieve the session state from the cookie that was set with the same cookie options
+ * If there is no match, return the first cookie, because that's how `getCookie()` works
+ */
+export function retrieveSessionCookie(cookieOptions: CookieOptions): SessionState {
+  if (isExperimentalFeatureEnabled(ExperimentalFeature.ENCODE_COOKIE_OPTIONS)) {
+    return retrieveSessionCookieFromEncodedCookie(cookieOptions)
+  }
+
   const sessionString = getCookie(SESSION_STORE_KEY)
   const sessionState = toSessionState(sessionString)
   return sessionState
@@ -83,3 +106,42 @@ export function buildCookieOptions(initConfiguration: InitConfiguration): Cookie
 
   return cookieOptions
 }
+
+function encodeCookieOptions(cookieOptions: CookieOptions): string {
+  const domainCount = cookieOptions.domain ? cookieOptions.domain.split('.').length - 1 : 0
+
+  /* eslint-disable no-bitwise */
+  let byte = 0
+  byte |= SESSION_COOKIE_VERSION << 5 // Store version in upper 3 bits
+  byte |= domainCount << 1 // Store domain count in next 4 bits
+  byte |= cookieOptions.crossSite ? 1 : 0 // Store useCrossSiteScripting in next bit
+  /* eslint-enable no-bitwise */
+
+  return byte.toString(16) // Convert to hex string
+}
+
+/**
+ * Retrieve the session state from the cookie that was set with the same cookie options.
+ * If there is no match, fallback to the first cookie, (because that's how `getCookie()` works)
+ * and this allows to keep the current session id when we release this feature.
+ */
+function retrieveSessionCookieFromEncodedCookie(cookieOptions: CookieOptions): SessionState {
+  const cookies = getCookies(SESSION_STORE_KEY)
+  const opts = encodeCookieOptions(cookieOptions)
+
+  let sessionState: SessionState | undefined
+
+  // reverse the cookies so that if there is no match, the cookie returned is the first one
+  for (const cookie of cookies.reverse()) {
+    sessionState = toSessionState(cookie)
+
+    if (sessionState.c === opts) {
+      break
+    }
+  }
+
+  // remove the cookie options from the session state as this is not part of the session state
+  delete sessionState?.c
+
+  return sessionState ?? {}
+}

package/src/domain/session/storeStrategies/sessionInLocalStorage.ts

@@ -34,7 +34,7 @@ function persistInLocalStorage(sessionState: SessionState) {
   localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState))
 }
 
-function retrieveSessionFromLocalStorage(): SessionState {
+export function retrieveSessionFromLocalStorage(): SessionState {
   const sessionString = localStorage.getItem(SESSION_STORE_KEY)
   return toSessionState(sessionString)
 }

package/src/domain/session/storeStrategies/sessionStoreStrategy.ts

@@ -2,7 +2,7 @@ import type { CookieOptions } from '../../../browser/cookie'
 import type { SessionPersistence } from '../sessionConstants'
 import type { SessionState } from '../sessionState'
 
-export const SESSION_STORE_KEY = '_dd_s'
+export const SESSION_STORE_KEY = '_md_s'
 
 export type SessionStoreStrategyType =
   | { type: typeof SessionPersistence.COOKIE; cookieOptions: CookieOptions }

package/src/domain/synthetics/syntheticsWorkerValues.ts

@@ -1,14 +1,14 @@
 import { getInitCookie } from '../../browser/cookie'
 import { globalObject, isWorkerEnvironment } from '../../tools/globalObject'
 
-export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id'
-export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id'
-export const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'datadog-synthetics-injects-rum'
+export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'motadata-synthetics-public-id'
+export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'motadata-synthetics-result-id'
+export const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'motadata-synthetics-injects-rum'
 
 export interface BrowserWindow extends Window {
-  _DATADOG_SYNTHETICS_PUBLIC_ID?: unknown
-  _DATADOG_SYNTHETICS_RESULT_ID?: unknown
-  _DATADOG_SYNTHETICS_INJECTS_RUM?: unknown
+  _MOTADATA_SYNTHETICS_PUBLIC_ID?: unknown
+  _MOTADATA_SYNTHETICS_RESULT_ID?: unknown
+  _MOTADATA_SYNTHETICS_INJECTS_RUM?: unknown
 }
 
 export function willSyntheticsInjectRum(): boolean {
@@ -18,18 +18,18 @@ export function willSyntheticsInjectRum(): boolean {
   }
 
   return Boolean(
-    (globalObject as BrowserWindow)._DATADOG_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
+    (globalObject as BrowserWindow)._MOTADATA_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
   )
 }
 
 export function getSyntheticsTestId(): string | undefined {
-  const value = (window as BrowserWindow)._DATADOG_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
+  const value = (window as BrowserWindow)._MOTADATA_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
   return typeof value === 'string' ? value : undefined
 }
 
 export function getSyntheticsResultId(): string | undefined {
   const value =
-    (window as BrowserWindow)._DATADOG_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
+    (window as BrowserWindow)._MOTADATA_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
   return typeof value === 'string' ? value : undefined
 }
 

package/src/domain/tags.ts

@@ -36,15 +36,15 @@ export function buildTag(key: string, rawValue?: string) {
   // warning.
   const tag = rawValue ? `${key}:${rawValue}` : key
 
-  if (tag.length > TAG_SIZE_LIMIT || hasForbiddenCharacters(tag)) {
-    display.warn(
-      `Tag ${tag} doesn't meet tag requirements and will be sanitized. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/tagging/#defining-tags`
-    )
-  }
+  // if (tag.length > TAG_SIZE_LIMIT || hasForbiddenCharacters(tag)) {
+  //   display.warn(
+  //     `Tag ${tag} doesn't meet tag requirements and will be sanitized. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/tagging/#defining-tags`
+  //   )
+  // }
 
   // Let the backend do most of the sanitization, but still make sure multiple tags can't be crafted
   // by forging a value containing commas.
-  return sanitizeTag(tag)
+  return tag
 }
 
 export function sanitizeTag(tag: string) {

package/src/domain/telemetry/telemetry.ts

@@ -5,7 +5,7 @@ import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
 import { getExperimentalFeatures } from '../../tools/experimentalFeatures'
 import type { Configuration } from '../configuration'
 import { buildTags } from '../tags'
-import { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../intakeSites'
+
 import { BufferedObservable, Observable } from '../../tools/observable'
 import { clocksNow } from '../../tools/utils/timeUtils'
 import { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor'
@@ -74,7 +74,7 @@ export const enum TelemetryMetrics {
 
 const METRIC_SAMPLE_RATE = 1
 
-const TELEMETRY_EXCLUDED_SITES: string[] = [INTAKE_SITE_US1_FED]
+const TELEMETRY_EXCLUDED_SITES: string[] = []
 
 let telemetryObservable: BufferedObservable<{ rawEvent: RawTelemetryEvent; metricName?: string }> | undefined
 
@@ -188,7 +188,7 @@ export function startTelemetryCollection(
       service: telemetryService,
       version: __BUILD_ENV__SDK_VERSION__,
       source: 'browser' as const,
-      _dd: {
+      _md: {
         format_version: 2 as const,
       },
       telemetry: combine(rawEvent, {
@@ -196,7 +196,7 @@ export function startTelemetryCollection(
         connectivity: getConnectivity(),
         sdk_setup: __BUILD_ENV__SDK_SETUP__,
       }) as TelemetryEvent['telemetry'],
-      ddtags: buildTags(configuration).join(','),
+      mdtags: buildTags(configuration).join(','),
       experimental_features: Array.from(getExperimentalFeatures()),
     }
 
@@ -262,7 +262,7 @@ export function resetTelemetry() {
  * but keep replicating staging events for reliability
  */
 function isTelemetryReplicationAllowed(configuration: Configuration) {
-  return configuration.site === INTAKE_SITE_STAGING
+  return false // No telemetry replication for custom sites
 }
 
 export function addTelemetryDebug(message: string, context?: Context) {

package/src/domain/telemetry/telemetryEvent.types.ts

@@ -540,7 +540,7 @@ export interface CommonTelemetryProperties {
   /**
    * Internal properties
    */
-  _dd: {
+  _md: {
     /**
      * Version of the RUM event format
      */

package/src/index.ts

@@ -68,6 +68,7 @@ export {
   BridgeCapability,
   createBatch,
   createFlushController,
+  setCurrentSite
 } from './transport'
 export * from './tools/display'
 export type { Encoder, EncoderResult } from './tools/encoder'

package/src/tools/display.ts

@@ -41,7 +41,7 @@ Object.keys(ConsoleApiName).forEach((name) => {
   originalConsoleMethods[name as ConsoleApiName] = globalConsole[name as ConsoleApiName]
 })
 
-const PREFIX = 'Datadog Browser SDK:'
+const PREFIX = 'Motadata Browser SDK:'
 
 export const display: Display = {
   debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),

package/src/tools/experimentalFeatures.ts

@@ -18,6 +18,7 @@ export enum ExperimentalFeature {
   USE_TREE_WALKER_FOR_ACTION_NAME = 'use_tree_walker_for_action_name',
   FEATURE_OPERATION_VITAL = 'feature_operation_vital',
   SHORT_SESSION_INVESTIGATION = 'short_session_investigation',
+  ENCODE_COOKIE_OPTIONS = 'encode_cookie_options',
 }
 
 const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()

package/src/tools/utils/browserDetection.ts

@@ -1,3 +1,126 @@
+// // Exported only for tests
+// export const enum Browser {
+//   CHROMIUM,
+//   SAFARI,
+//   OTHER,
+// }
+//
+// export function isChromium() {
+//   return detectBrowserCached() === Browser.CHROMIUM
+// }
+//
+// export function isSafari() {
+//   return detectBrowserCached() === Browser.SAFARI
+// }
+//
+// let browserCache: Browser | undefined
+// function detectBrowserCached() {
+//   return browserCache ?? (browserCache = detectBrowser())
+// }
+//
+// // Exported only for tests
+// export function detectBrowser(browserWindow: Window = window) {
+//   const userAgent = browserWindow.navigator.userAgent
+//   if ((browserWindow as any).chrome || /HeadlessChrome/.test(userAgent)) {
+//     return Browser.CHROMIUM
+//   }
+//
+//   if (
+//     // navigator.vendor is deprecated, but it is the most resilient way we found to detect
+//     // "Apple maintained browsers" (AKA Safari). If one day it gets removed, we still have the
+//     // useragent test as a semi-working fallback.
+//     browserWindow.navigator.vendor?.indexOf('Apple') === 0 ||
+//     (/safari/i.test(userAgent) && !/chrome|android/i.test(userAgent))
+//   ) {
+//     return Browser.SAFARI
+//   }
+//
+//   return Browser.OTHER
+// }
+//
+// /**
+//  * Get detailed browser name for X-Browser-Name header
+//  * Returns one of: Chrome, Firefox, Edge, Opera, Safari, other
+//  */
+// let detailedBrowserNameCache: string | undefined
+// export function getDetailedBrowserName(browserWindow: Window = window): string {
+//   return detailedBrowserNameCache ?? (detailedBrowserNameCache = detectDetailedBrowserName(browserWindow))
+// }
+//
+// // Exported only for tests
+// export function detectDetailedBrowserName(browserWindow: Window = window): string {
+//   // Try Client Hints API first for more accurate detection
+//   const clientHintsBrowser = parseClientHints(browserWindow)
+//   if (clientHintsBrowser) {
+//     return clientHintsBrowser
+//   }
+//
+//   // Fallback to user agent parsing
+//   return parseUserAgent(browserWindow)
+// }
+//
+// function parseClientHints(browserWindow: Window = window): string {
+//
+//   // fallback to userAgent
+//   const ua = browserWindow.navigator.userAgent
+//
+//   if (/edg/i.test(ua)) {
+//     return 'Edge';
+//   }
+//   if (/opr|opera/i.test(ua)) {return 'Opera'}
+//   if (/chrome/i.test(ua)) {return 'Chrome'}
+//   if (/safari/i.test(ua)) {return 'Safari'}
+//   if (/firefox/i.test(ua)) {return 'Firefox'}
+//
+//   return 'other'
+// }
+//
+// function parseUserAgent(browserWindow: Window = window): string {
+//   const userAgent = browserWindow.navigator.userAgent
+//
+//   // Firefox detection
+//   if (/Firefox\//i.test(userAgent)) {
+//     return 'Firefox'
+//   }
+//
+//   // Safari detection (must come before Chrome check)
+//   if (
+//     (browserWindow.navigator.vendor?.indexOf('Apple') === 0 ||
+//       (/safari/i.test(userAgent) && !/chrome|android/i.test(userAgent)))
+//   ) {
+//     return 'Safari'
+//   }
+//
+//   // Chrome-based browsers detection
+//   if (/Chrome\//i.test(userAgent) || (browserWindow as any).chrome || /HeadlessChrome/.test(userAgent)) {
+//     // Edge detection
+//     if (/Edg\//i.test(userAgent)) {
+//       return 'Edge'
+//     }
+//
+//     // Opera detection
+//     if (/OPR\//i.test(userAgent) || /Opera\//i.test(userAgent)) {
+//       return 'Opera'
+//     }
+//
+//     // Brave detection (fallback - Brave shows as Chrome in user agent)
+//     // Note: This is less reliable than Client Hints, but better than nothing
+//     if (/Brave\//i.test(userAgent)) {
+//       return 'other'
+//     }
+//
+//     // Default Chrome detection
+//     return 'Chrome'
+//   }
+//
+//   // All other browsers
+//   return 'other'
+// }
+
+
+// eslint-disable-next-line import/no-extraneous-dependencies, local-rules/disallow-side-effects, local-rules/enforce-prod-deps-imports
+import { UAParser } from 'ua-parser-js';
+
 // Exported only for tests
 export const enum Browser {
   CHROMIUM,
@@ -37,3 +160,26 @@ export function detectBrowser(browserWindow: Window = window) {
 
   return Browser.OTHER
 }
+
+/**
+ * Get detailed browser name for X-Browser-Name header
+ * Uses ua-parser-js for accurate browser detection
+ */
+let detailedBrowserNameCache: string | undefined
+
+export function getDetailedBrowserName(browserWindow: Window = window): string {
+  return (
+    detailedBrowserNameCache ??
+    (detailedBrowserNameCache = detectDetailedBrowserName(browserWindow))
+  )
+}
+
+export function detectDetailedBrowserName(browserWindow: Window = window): string {
+  const ua = browserWindow.navigator.userAgent
+  const parser = new UAParser(ua)
+  const result = parser.getResult()
+
+  // Return the browser name from ua-parser-js
+  // If browser name is undefined or empty, return 'Unknown Browser'
+  return result.browser.name || 'Unknown Browser'
+}

package/src/tools/utils/stringUtils.ts

@@ -11,6 +11,10 @@ export function generateUUID(placeholder?: string): string {
 
 const COMMA_SEPARATED_KEY_VALUE = /([\w-]+)\s*=\s*([^;]+)/g
 
+/**
+ * Returns the value of the key with the given name
+ * If there are multiple values with the same key, returns the first one
+ */
 export function findCommaSeparatedValue(rawString: string, name: string): string | undefined {
   COMMA_SEPARATED_KEY_VALUE.lastIndex = 0
   while (true) {
@@ -25,6 +29,36 @@ export function findCommaSeparatedValue(rawString: string, name: string): string
   }
 }
 
+/**
+ * Returns a map of all the values with the given key
+ * If there are multiple values with the same key, returns all the values
+ */
+export function findAllCommaSeparatedValues(rawString: string): Map<string, string[]> {
+  const result = new Map<string, string[]>()
+  COMMA_SEPARATED_KEY_VALUE.lastIndex = 0
+  while (true) {
+    const match = COMMA_SEPARATED_KEY_VALUE.exec(rawString)
+    if (match) {
+      const key = match[1]
+      const value = match[2]
+      if (result.has(key)) {
+        result.get(key)!.push(value)
+      } else {
+        result.set(key, [value])
+      }
+    } else {
+      break
+    }
+  }
+  return result
+}
+
+/**
+ * Returns a map of the values with the given key
+ * ⚠️ If there are multiple values with the same key, returns the LAST one
+ *
+ * @deprecated use `findAllCommaSeparatedValues()` instead
+ */
 export function findCommaSeparatedValues(rawString: string): Map<string, string> {
   const result = new Map<string, string>()
   COMMA_SEPARATED_KEY_VALUE.lastIndex = 0