@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/src/browser/xhrObservable.ts

@@ -1,11 +1,9 @@
+import { elapsed, timeStampNow, clocksNow } from '@kubesense/kubesense-js-core/time'
+import type { Duration, ClocksState } from '@kubesense/kubesense-js-core/time'
+import { normalizeUrl, globalObject } from '@kubesense/kubesense-js-core/util'
 import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
 import { instrumentMethod } from '../tools/instrumentMethod'
 import { Observable } from '../tools/observable'
-import type { Duration, ClocksState } from '../tools/utils/timeUtils'
-import { elapsed, clocksNow, timeStampNow } from '../tools/utils/timeUtils'
-import { normalizeUrl } from '../tools/utils/urlPolyfill'
-import { shallowClone } from '../tools/utils/objectUtils'
-import type { Configuration } from '../domain/configuration'
 import { addEventListener } from './addEventListener'
 
 export interface XhrOpenContext {
@@ -35,14 +33,18 @@ export type XhrContext = XhrOpenContext | XhrStartContext | XhrCompleteContext
 let xhrObservable: Observable<XhrContext> | undefined
 const xhrContexts = new WeakMap<XMLHttpRequest, XhrContext>()
 
-export function initXhrObservable(configuration: Configuration) {
+export function initXhrObservable() {
   if (!xhrObservable) {
-    xhrObservable = createXhrObservable(configuration)
+    xhrObservable = createXhrObservable()
   }
   return xhrObservable
 }
 
-function createXhrObservable(configuration: Configuration) {
+function createXhrObservable() {
+  if (!('XMLHttpRequest' in globalObject)) {
+    return new Observable<XhrContext>()
+  }
+
   return new Observable<XhrContext>((observable) => {
     const { stop: stopInstrumentingStart } = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr)
 
@@ -50,7 +52,7 @@ function createXhrObservable(configuration: Configuration) {
       XMLHttpRequest.prototype,
       'send',
       (call) => {
-        sendXhr(call, configuration, observable)
+        sendXhr(call, observable)
       },
       { computeHandlingStack: true }
     )
@@ -75,7 +77,6 @@ function openXhr({ target: xhr, parameters: [method, url] }: InstrumentedMethodC
 
 function sendXhr(
   { target: xhr, parameters: [body], handlingStack }: InstrumentedMethodCall<XMLHttpRequest, 'send'>,
-  configuration: Configuration,
   observable: Observable<XhrContext>
 ) {
   const context = xhrContexts.get(xhr)
@@ -112,16 +113,15 @@ function sendXhr(
     hasBeenReported = true
 
     const completeContext = context as XhrCompleteContext
-    completeContext.state = 'complete'
     completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow())
     completeContext.status = xhr.status
     if (typeof xhr.response === 'string') {
       completeContext.responseBody = xhr.response
     }
-    observable.notify(shallowClone(completeContext))
+    observable.notify({ ...completeContext, state: 'complete' })
   }
 
-  const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, xhr, 'loadend', onEnd)
+  const { stop: unsubscribeLoadEndListener } = addEventListener(xhr, 'loadend', onEnd)
 
   observable.notify(startContext)
 }
@@ -132,3 +132,12 @@ function abortXhr({ target: xhr }: InstrumentedMethodCall<XMLHttpRequest, 'abort
     context.isAborted = true
   }
 }
+
+/**
+ * Reset the XHR observable global state. This is useful for testing to ensure clean state between tests.
+ *
+ * @internal
+ */
+export function resetXhrObservable() {
+  xhrObservable = undefined
+}

package/src/domain/allowedTrackingOrigins.ts

@@ -1,21 +1,22 @@
+import { globalObject } from '@kubesense/kubesense-js-core/util'
 import { display } from '../tools/display'
 import { matchList } from '../tools/matchOption'
-import type { InitConfiguration } from './configuration'
+import { mockable } from '../tools/mockable'
+import type { Configuration } from './configuration'
 import { isUnsupportedExtensionEnvironment } from './extension/extensionUtils'
 
 export const ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN =
   'Running the Browser SDK in a Web extension content script is forbidden unless the `allowedTrackingOrigins` option is provided.'
 export const ERROR_NOT_ALLOWED_TRACKING_ORIGIN = 'SDK initialized on a non-allowed domain.'
 
-export function isAllowedTrackingOrigins(
-  configuration: InitConfiguration,
-  errorStack: string,
-  windowOrigin = typeof location !== 'undefined' ? location.origin : ''
-): boolean {
+export function isAllowedTrackingOrigins(configuration: Configuration, errorStack: string): boolean {
+  const location = mockable(globalObject.location)
+  const windowOrigin = location ? location.origin : ''
   const allowedTrackingOrigins = configuration.allowedTrackingOrigins
   if (!allowedTrackingOrigins) {
     if (isUnsupportedExtensionEnvironment(windowOrigin, errorStack)) {
       display.error(ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN)
+
       return false
     }
     return true

package/src/domain/bufferedData.ts

@@ -1,32 +1,59 @@
+import { ConsoleApiName } from '@kubesense/kubesense-js-core/util'
+import type { Observable, Subscription } from '../tools/observable'
 import { BufferedObservable } from '../tools/observable'
+import { mockable } from '../tools/mockable'
+import type { FetchContext } from '../browser/fetchObservable'
+import { initFetchObservable } from '../browser/fetchObservable'
+import type { XhrContext } from '../browser/xhrObservable'
+import { initXhrObservable } from '../browser/xhrObservable'
+import { addTelemetryDebug } from './telemetry'
 import type { RawError } from './error/error.types'
 import { trackRuntimeError } from './error/trackRuntimeError'
+import type { ConsoleLog } from './console/consoleObservable'
+import { initConsoleObservable } from './console/consoleObservable'
 
 const BUFFER_LIMIT = 500
 
 export const enum BufferedDataType {
   RUNTIME_ERROR,
+  FETCH,
+  XHR,
+  CONSOLE,
 }
 
-export interface BufferedData {
-  type: BufferedDataType.RUNTIME_ERROR
-  error: RawError
-}
-
-export function startBufferingData(trackRuntimeErrorImpl = trackRuntimeError) {
-  const observable = new BufferedObservable<BufferedData>(BUFFER_LIMIT)
+export type BufferedData =
+  | { type: BufferedDataType.RUNTIME_ERROR; data: RawError }
+  | { type: BufferedDataType.FETCH; data: FetchContext }
+  | { type: BufferedDataType.XHR; data: XhrContext }
+  | { type: BufferedDataType.CONSOLE; data: ConsoleLog }
 
-  const runtimeErrorSubscription = trackRuntimeErrorImpl().subscribe((error) => {
-    observable.notify({
-      type: BufferedDataType.RUNTIME_ERROR,
-      error,
+export function startBufferingData() {
+  const observable = new BufferedObservable<BufferedData>(BUFFER_LIMIT, (count) => {
+    // monitor-until: 2026-10-14
+    addTelemetryDebug('Early data collection dropped data on unbuffer', {
+      count,
     })
   })
+  const subscriptions: Subscription[] = []
+
+  function subscribe<T extends BufferedDataType>(
+    type: T,
+    source: Observable<Extract<BufferedData, { type: T }>['data']>
+  ) {
+    subscriptions.push(
+      source.subscribe((data) => {
+        observable.notify({ type, data } as BufferedData)
+      })
+    )
+  }
+
+  subscribe(BufferedDataType.RUNTIME_ERROR, mockable(trackRuntimeError)())
+  subscribe(BufferedDataType.FETCH, initFetchObservable())
+  subscribe(BufferedDataType.XHR, initXhrObservable())
+  subscribe(BufferedDataType.CONSOLE, initConsoleObservable(Object.values(ConsoleApiName)))
 
   return {
     observable,
-    stop: () => {
-      runtimeErrorSubscription.unsubscribe()
-    },
+    stop: () => subscriptions.forEach((subscription) => subscription.unsubscribe()),
   }
 }

package/src/domain/configuration/configuration.ts

@@ -1,18 +1,9 @@
-import { catchUserErrors } from '../../tools/catchUserErrors'
-import { DOCS_ORIGIN, MORE_DETAILS, display } from '../../tools/display'
+import type { ProxyFn, Site } from '@kubesense/kubesense-js-core/transport'
+import { INTAKE_SITE_PROD } from '@kubesense/kubesense-js-core/transport'
+import type { InferredConfig, MatchOption } from '@kubesense/kubesense-js-core/configuration'
 import type { RawTelemetryConfiguration } from '../telemetry'
-import { isPercentage } from '../../tools/utils/numberUtils'
-import { objectHasValue } from '../../tools/utils/objectUtils'
-import { selectSessionStoreStrategyType } from '../session/sessionStore'
-import type { SessionStoreStrategyType } from '../session/storeStrategies/sessionStoreStrategy'
 import { TrackingConsent } from '../trackingConsent'
 import type { SessionPersistence } from '../session/sessionConstants'
-import type { MatchOption } from '../../tools/matchOption'
-import { isAllowedTrackingOrigins } from '../allowedTrackingOrigins'
-import { isWorkerEnvironment } from '../../tools/globalObject'
-import type { TransportConfiguration } from './transportConfiguration'
-import { computeTransportConfiguration } from './transportConfiguration'
-import type { Site } from '../intakeSites'
 
 /**
  * Default privacy level for the browser SDK.
@@ -52,12 +43,14 @@ export interface InitConfiguration {
    * @category Authentication
    */
   clientToken: string
+
   /**
    * A callback function that can be used to modify events before they are sent to KubeSense.
    *
-   *  @category Data Collection
+   * @category Data Collection
    */
   beforeSend?: GenericBeforeSendCallback | undefined
+
   /**
    * The percentage of sessions tracked. A value between 0 and 100.
    *
@@ -65,6 +58,7 @@ export interface InitConfiguration {
    * @defaultValue 100
    */
   sessionSampleRate?: number | undefined
+
   /**
    * The percentage of telemetry events sent. A value between 0 and 100.
    *
@@ -72,43 +66,45 @@ export interface InitConfiguration {
    * @defaultValue 20
    */
   telemetrySampleRate?: number | undefined
+
   /**
    * Initialization fails silently if the RUM Browser SDK is already initialized on the page.
+   *
    * @defaultValue false
    */
   silentMultipleInit?: boolean | undefined
 
   /**
-   * Which storage strategy to use for persisting sessions. Can be either 'cookie' or 'local-storage'.
+   * Which storage strategy to use for persisting sessions. Can be 'cookie', 'local-storage', or 'memory'.
+   * When an array is provided, the SDK will attempt each persistence type in the order specified.
    *
    * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
    *
-   * @category Session Persistence
-   * @defaultValue "cookie"
-   */
-  sessionPersistence?: SessionPersistence | undefined
-
-  /**
-   * Allows the use of localStorage when cookies cannot be set. This enables the RUM Browser SDK to run in environments that do not provide cookie support.
+   * Note: 'memory' option is only for use with single-page applications. All page loads will start a new session, likely resulting in an increase in total number of RUM sessions
    *
-   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
    * @category Session Persistence
-   * @deprecated use `sessionPersistence: local-storage` where you want to use localStorage instead
+   * @defaultValue "cookie"
    */
-  allowFallbackToLocalStorage?: boolean | undefined
+  sessionPersistence?: SessionPersistence | SessionPersistence[] | undefined
 
   /**
    * Allow listening to DOM events dispatched programmatically ([untrusted events](https://developer.mozilla.org/en-US/docs/Web/API/Event/isTrusted)). Enabling this option can be useful if you heavily rely on programmatic events, such as in an automated UI test environment.
+   *
    * @defaultValue false
    */
   allowUntrustedEvents?: boolean | undefined
+
   /**
    * Store global context and user context in localStorage to preserve them along the user navigation.
+   * See [Contexts life cycle](https://docs.kubesense.ai/real_user_monitoring/browser/advanced_configuration/?tab=npm#contexts-life-cycle) for further information.
+   *
    * @defaultValue false
    */
   storeContextsAcrossPages?: boolean | undefined
+
   /**
    * Set the initial user tracking consent state.
+   * See [User tracking consent](https://docs.kubesense.ai/real_user_monitoring/browser/advanced_configuration/?tab=npm#user-tracking-consent) for further information.
    *
    * @category Privacy
    * @defaultValue granted
@@ -125,34 +121,39 @@ export interface InitConfiguration {
   // transport options
   /**
    * Optional proxy URL, for example: https://www.proxy.com/path.
+   * See [Proxy Your Browser RUM Data](https://docs.kubesense.ai/real_user_monitoring/guide/proxy-rum-data) for further information.
    *
    * @category Transport
    */
   proxy?: string | ProxyFn | undefined
+
   /**
+   * The KubeSense RUM intake host that events are sent to, for example `us2.kubesense.ai`.
    *
    * @category Transport
-   * @defaultValue rum.kubesense.ai
+   * @defaultValue us2.kubesense.ai
    */
-  kubesenseRumEndpoint?: Site | undefined | null
+  kubesenseRumEndpoint?: Site | undefined
 
   // tag and context options
   /**
-   * The service name for your application.
+   * The service name for your application. Follows the [tag syntax requirements](https://docs.kubesense.ai/getting_started/tagging/#define-tags).
    *
-   *  @category Data Collection
+   * @category Data Collection
    */
   service?: string | undefined | null
+
   /**
-   * The application’s environment, for example: prod, pre-prod, and staging.
+   * The application’s environment, for example: prod, pre-prod, and staging. Follows the [tag syntax requirements](https://docs.kubesense.ai/getting_started/tagging/#define-tags).
    *
-   *  @category Data Collection
+   * @category Data Collection
    */
   env?: string | undefined | null
+
   /**
-   * The application’s version, for example: 1.2.3, 6c44da20, and 2020.02.13.
+   * The application’s version, for example: 1.2.3, 6c44da20, and 2020.02.13. Follows the [tag syntax requirements](https://docs.kubesense.ai/getting_started/tagging/#define-tags).
    *
-   *  @category Data Collection
+   * @category Data Collection
    */
   version?: string | undefined | null
 
@@ -161,70 +162,73 @@ export interface InitConfiguration {
    * Use a partitioned secure cross-site session cookie. This allows the RUM Browser SDK to run when the site is loaded from another one (iframe). Implies `useSecureSessionCookie`.
    *
    * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
+   *
    * @category Session Persistence
    * @defaultValue false
    */
   usePartitionedCrossSiteSessionCookie?: boolean | undefined
+
   /**
    * Use a secure session cookie. This disables RUM events sent on insecure (non-HTTPS) connections.
    *
    * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
+   *
    * @category Session Persistence
    * @defaultValue false
    */
   useSecureSessionCookie?: boolean | undefined
+
   /**
    * Preserve the session across subdomains for the same site.
    *
    * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
+   *
    * @category Session Persistence
    * @defaultValue false
    */
   trackSessionAcrossSubdomains?: boolean | undefined
+
   /**
    * Track anonymous user for the same site and extend cookie expiration date
+   *
    * @category Data Collection
    * @defaultValue true
    */
   trackAnonymousUser?: boolean | undefined
-  /**
-   * Encode cookie options in the cookie value. This can be used as a mitigation for microssession issues.
-   * ⚠️ This is a beta feature and may be changed or removed in the future.
-   *
-   * @category Beta
-   * @defaultValue false
-   */
-  betaEncodeCookieOptions?: boolean | undefined
+
   // internal options
   /**
    * [Internal option] Enable experimental features
+   *
    * @internal
    */
   enableExperimentalFeatures?: string[] | undefined
+
   /**
    * [Internal option] Configure the dual shipping to another datacenter
+   *
    * @internal
    */
-  replica?: ReplicaUserConfiguration | undefined
+  replica?: ReplicaInitConfiguration | undefined
+
   /**
    * [Internal option] Set the datacenter from where the data is dual shipped
+   *
    * @internal
    */
   datacenter?: string
-  /**
-   * [Internal option] KubeSense internal analytics subdomain
-   * @internal
-   */
-  // TODO next major: remove this option and replace usages by proxyFn
-  internalAnalyticsSubdomain?: string
+
   /**
    * [Internal option] The percentage of telemetry configuration sent. A value between 0 and 100.
+   *
    * @internal
    * @defaultValue 5
    */
   telemetryConfigurationSampleRate?: number
+
   /**
    * [Internal option] The percentage of telemetry usage sent. A value between 0 and 100.
+   *
    * @internal
    * @defaultValue 5
    */
@@ -238,17 +242,17 @@ export interface InitConfiguration {
   source?: 'browser' | 'flutter' | 'unity' | undefined
 
   /**
-  * [Internal option] Additional configuration for the SDK.
-  *
-  * @internal
-  */
+   * [Internal option] Additional configuration for the SDK.
+   *
+   * @internal
+   */
   sdkVersion?: string | undefined
 
   /**
-  * [Internal option] Additional configuration for the SDK.
-  *
-  * @internal
-  */
+   * [Internal option] Additional configuration for the SDK.
+   *
+   * @internal
+   */
   variant?: string | undefined
 }
 
@@ -257,130 +261,76 @@ export interface InitConfiguration {
 type GenericBeforeSendCallback = (event: any, context?: any) => unknown
 
 /**
- * path: /api/vX/product
- * parameters: xxx=yyy&zzz=aaa
+ * @internal
  */
-export type ProxyFn = (options: { path: string; parameters: string }) => string
-
-export interface ReplicaUserConfiguration {
+export interface ReplicaInitConfiguration {
   applicationId?: string
   clientToken: string
 }
 
-export interface Configuration extends TransportConfiguration {
-  // Built from init configuration
-  beforeSend: GenericBeforeSendCallback | undefined
-  sessionStoreStrategyType: SessionStoreStrategyType | undefined
-  sessionSampleRate: number
-  telemetrySampleRate: number
-  telemetryConfigurationSampleRate: number
-  telemetryUsageSampleRate: number
-  service: string | undefined
-  version?: string | undefined
-  env?: string | undefined
-  silentMultipleInit: boolean
-  allowUntrustedEvents: boolean
-  trackingConsent: TrackingConsent
-  storeContextsAcrossPages: boolean
-  trackAnonymousUser?: boolean
-  betaEncodeCookieOptions: boolean
-
-  // internal
-  sdkVersion: string | undefined
-  source: 'browser' | 'flutter' | 'unity'
-  variant: string | undefined
-}
+export type SdkSource = 'browser' | 'flutter' | 'unity'
 
-function isString(tag: unknown, tagName: string): tag is string | undefined | null {
-  if (tag !== undefined && tag !== null && typeof tag !== 'string') {
-    display.error(`${tagName} must be defined as a string`)
-    return false
-  }
-  return true
-}
+export const BROWSER_CORE_SCHEMA = {
+  clientToken: { type: 'string', required: true },
 
-function isKubeSenseSite(site: unknown) {
-  if (site && typeof site === 'string' && !/(kubesense|tyke)/.test(site)) {
-    display.error(`Site should be a valid KubeSense site. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/site/.`)
-    return false
-  }
-  return true
-}
+  // Optional tag fields
+  service: { type: 'string' },
+  env: { type: 'string' },
+  version: { type: 'string' },
 
-export function isSampleRate(sampleRate: unknown, name: string) {
-  if (sampleRate !== undefined && !isPercentage(sampleRate)) {
-    display.error(`${name} Sample Rate should be a number between 0 and 100`)
-    return false
-  }
-  return true
-}
+  // Transport
+  kubesenseRumEndpoint: { type: 'site', default: INTAKE_SITE_PROD },
+  proxy: {
+    type: 'union',
+    variants: [{ type: 'string' }, { type: 'function', signature: undefined as ProxyFn | undefined }],
+  },
 
-export function validateAndBuildConfiguration(
-  initConfiguration: InitConfiguration,
-  errorStack?: string
-): Configuration | undefined {
-  if (!initConfiguration || !initConfiguration.clientToken) {
-    display.error('Client Token is not configured, we will not send any data.')
-    return
-  }
-
-  if (
-    initConfiguration.allowedTrackingOrigins !== undefined &&
-    !Array.isArray(initConfiguration.allowedTrackingOrigins)
-  ) {
-    display.error('Allowed Tracking Origins must be an array')
-    return
-  }
-
-  if (
-    // !isKubeSenseSite(initConfiguration.kubesenseRumEndpoint) ||
-    !isSampleRate(initConfiguration.sessionSampleRate, 'Session') ||
-    !isSampleRate(initConfiguration.telemetrySampleRate, 'Telemetry') ||
-    !isSampleRate(initConfiguration.telemetryConfigurationSampleRate, 'Telemetry Configuration') ||
-    !isSampleRate(initConfiguration.telemetryUsageSampleRate, 'Telemetry Usage') ||
-    !isString(initConfiguration.version, 'Version') ||
-    !isString(initConfiguration.env, 'Env') ||
-    !isString(initConfiguration.service, 'Service') ||
-    !isAllowedTrackingOrigins(initConfiguration, errorStack ?? '')
-  ) {
-    return
-  }
-
-  if (
-    initConfiguration.trackingConsent !== undefined &&
-    !objectHasValue(TrackingConsent, initConfiguration.trackingConsent)
-  ) {
-    display.error('Tracking Consent should be either "granted" or "not-granted"')
-    return
-  }
+  // Sample rates
+  sessionSampleRate: { type: 'percentage', default: 100 },
+  telemetrySampleRate: { type: 'percentage', default: 20 },
+  telemetryConfigurationSampleRate: { type: 'percentage', default: 5 },
+  telemetryUsageSampleRate: { type: 'percentage', default: 5 },
 
-  return {
-    beforeSend:
-      initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),
-    sessionStoreStrategyType: isWorkerEnvironment ? undefined : selectSessionStoreStrategyType(initConfiguration),
-    sessionSampleRate: initConfiguration.sessionSampleRate ?? 100,
-    telemetrySampleRate: initConfiguration.telemetrySampleRate ?? 20,
-    telemetryConfigurationSampleRate: initConfiguration.telemetryConfigurationSampleRate ?? 5,
-    telemetryUsageSampleRate: initConfiguration.telemetryUsageSampleRate ?? 5,
-    service: initConfiguration.service ?? undefined,
-    env: initConfiguration.env ?? undefined,
-    version: initConfiguration.version ?? undefined,
-    datacenter: initConfiguration.datacenter ?? undefined,
-    silentMultipleInit: !!initConfiguration.silentMultipleInit,
-    allowUntrustedEvents: !!initConfiguration.allowUntrustedEvents,
-    trackingConsent: initConfiguration.trackingConsent ?? TrackingConsent.GRANTED,
-    trackAnonymousUser: initConfiguration.trackAnonymousUser ?? true,
-    storeContextsAcrossPages: !!initConfiguration.storeContextsAcrossPages,
-    betaEncodeCookieOptions: !!initConfiguration.betaEncodeCookieOptions,
-    /**
-     * The source of the SDK, used for support plugins purposes.
-     */
-    variant: initConfiguration.variant,
-    sdkVersion: initConfiguration.sdkVersion,
+  // Booleans
+  silentMultipleInit: { type: 'boolean', default: false, strict: false },
+  storeContextsAcrossPages: { type: 'boolean', default: false, strict: false },
+  trackAnonymousUser: { type: 'boolean', default: true, strict: false },
+  useSecureSessionCookie: { type: 'boolean', default: false, strict: false },
+  usePartitionedCrossSiteSessionCookie: { type: 'boolean', default: false, strict: false },
+  trackSessionAcrossSubdomains: { type: 'boolean', default: false, strict: false },
 
-    ...computeTransportConfiguration(initConfiguration),
-  }
-}
+  // Cookie/extension origin validation
+  allowedTrackingOrigins: { type: 'match-option', multiple: true, strict: false },
+
+  // Privacy
+  trackingConsent: { type: 'enum', values: TrackingConsent, default: TrackingConsent.GRANTED },
+
+  // Callbacks
+  beforeSend: { type: 'function', signature: undefined as GenericBeforeSendCallback | undefined },
+
+  // Passthroughs
+  source: { type: 'enum', values: ['browser', 'flutter', 'unity'] as const, default: 'browser', strict: false },
+  sessionPersistence: {
+    type: 'enum',
+    values: ['cookie', 'local-storage', 'memory'] as const,
+    multiple: true,
+    strict: false,
+  },
+  replica: {
+    type: 'schema',
+    schema: {
+      clientToken: { type: 'string', required: true },
+      applicationId: { type: 'string' },
+    },
+  },
+
+  // Internal
+  datacenter: { type: 'string' },
+  sdkVersion: { type: 'string' },
+  variant: { type: 'string' },
+} as const
+
+export type Configuration = InferredConfig<typeof BROWSER_CORE_SCHEMA>
 
 export function serializeConfiguration(initConfiguration: InitConfiguration) {
   return {
@@ -395,13 +345,13 @@ export function serializeConfiguration(initConfiguration: InitConfiguration) {
     silent_multiple_init: initConfiguration.silentMultipleInit,
     track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,
     track_anonymous_user: initConfiguration.trackAnonymousUser,
-    session_persistence: initConfiguration.sessionPersistence,
-    allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,
+    session_persistence: Array.isArray(initConfiguration.sessionPersistence)
+      ? initConfiguration.sessionPersistence[0]
+      : initConfiguration.sessionPersistence,
     store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,
     allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,
     tracking_consent: initConfiguration.trackingConsent,
     use_allowed_tracking_origins: Array.isArray(initConfiguration.allowedTrackingOrigins),
-    beta_encode_cookie_options: initConfiguration.betaEncodeCookieOptions,
     source: initConfiguration.source,
     sdk_version: initConfiguration.sdkVersion,
     variant: initConfiguration.variant,