swetrix 4.2.0 → 4.4.0

package/src/Lib.ts

@@ -14,6 +14,38 @@ import {
   getPath,
 } from './utils.js'
 
+type RrwebEvent = Record<string, unknown>
+
+type RrwebEmit = (event: RrwebEvent) => void
+
+interface RrwebRecordOptions {
+  emit?: RrwebEmit
+  [key: string]: unknown
+}
+
+interface RrwebGlobal {
+  record?: (options: RrwebRecordOptions) => (() => void) | undefined
+  Replayer?: unknown
+}
+
+type RrwebModule = RrwebGlobal & {
+  default?: RrwebGlobal
+}
+
+type SessionReplayPreloadOption = boolean | { rrwebUrl?: string }
+
+interface SessionReplayStartResponse {
+  replayId: string
+  nextChunkIndex: number
+}
+
+declare global {
+  interface Window {
+    rrweb?: RrwebGlobal
+    __SWETRIX_RRWEB_LOADING__?: Promise<void>
+  }
+}
+
 export interface LibOptions {
   /**
    * When set to `true`, localhost events will be sent to server.
@@ -39,6 +71,11 @@ export interface LibOptions {
    * If set, it will be used for all pageviews and events unless overridden per-call.
    */
   profileId?: string
+
+  /**
+   * Preload session replay recorder code. Recording only starts after calling startSessionReplay().
+   */
+  preloadSessionReplay?: SessionReplayPreloadOption
 }
 
 export interface TrackEventOptions {
@@ -166,6 +203,30 @@ export interface ErrorActions {
   stop: () => void
 }
 
+const SESSION_REPLAY_PRIVACY_VALUES = ['total', 'normal', 'none'] as const
+
+export type SessionReplayPrivacy =
+  (typeof SESSION_REPLAY_PRIVACY_VALUES)[number]
+
+export interface SessionReplayOptions {
+  privacy?: SessionReplayPrivacy
+  rrweb?: RrwebRecordOptions
+  flushIntervalMs?: number
+  maxEventsPerChunk?: number
+  maxBytesPerChunk?: number
+  maxBytesPerEvent?: number
+  sampleRate?: number
+  maxDurationMs?: number
+  idleTimeoutMs?: number
+  maskAllText?: boolean
+  recordIframes?: boolean
+}
+
+export interface SessionReplayActions {
+  stop: () => Promise<void>
+  flush: () => Promise<void>
+}
+
 export interface PageData {
   /** Current URL path. */
   path: string
@@ -228,12 +289,62 @@ export const defaultActions = {
   stop() {},
 }
 
+export const defaultSessionReplayActions: SessionReplayActions = {
+  async stop() {},
+  async flush() {},
+}
+
 const DEFAULT_API_HOST = 'https://api.swetrix.com/log'
 const DEFAULT_API_BASE = 'https://api.swetrix.com'
+const DEFAULT_RRWEB_FILE = 'replaylibrary.min.js'
+const DEFAULT_RRWEB_URL = `https://cdn.jsdelivr.net/npm/swetrix@latest/dist/${DEFAULT_RRWEB_FILE}`
+const DEFAULT_SESSION_REPLAY_FLUSH_INTERVAL = 5000
+const DEFAULT_SESSION_REPLAY_MAX_EVENTS = 100
+const DEFAULT_SESSION_REPLAY_MAX_CHUNK_BYTES = 512 * 1024
+const DEFAULT_SESSION_REPLAY_MAX_EVENT_BYTES = 5 * 1024 * 1024
+const DEFAULT_SESSION_REPLAY_MAX_DURATION_MS = 30 * 60 * 1000
+const DEFAULT_SESSION_REPLAY_PRIVACY: SessionReplayPrivacy = 'total'
+const DEFAULT_SESSION_REPLAY_SAMPLING = {
+  mousemove: 50,
+  scroll: 150,
+  input: 'last',
+}
+const DEFAULT_SESSION_REPLAY_SLIM_DOM_OPTIONS = {
+  script: true,
+  comment: true,
+  headFavicon: true,
+  headWhitespace: true,
+  headMetaDescKeywords: true,
+  headMetaSocial: true,
+  headMetaRobots: true,
+  headMetaHttpEquiv: true,
+  headMetaAuthorship: true,
+  headMetaVerification: true,
+}
+const SESSION_REPLAY_ACTIVITY_EVENTS = [
+  'click',
+  'keydown',
+  'mousedown',
+  'mousemove',
+  'scroll',
+  'touchstart',
+] as const
 
 // Default cache duration: 5 minutes
 const DEFAULT_CACHE_DURATION = 5 * 60 * 1000
 
+const getStringByteLength = (value: string) => {
+  if (typeof TextEncoder !== 'undefined') {
+    return new TextEncoder().encode(value).length
+  }
+
+  if (typeof Blob !== 'undefined') {
+    return new Blob([value]).size
+  }
+
+  return value.length
+}
+
 export class Lib {
   private pageData: PageData | null = null
   private pageViewsOptions?: PageViewsOptions | null = null
@@ -242,11 +353,18 @@ export class Lib {
   private activePage: string | null = null
   private errorListenerExists = false
   private cachedData: CachedData | null = null
+  private rrwebLoader: Promise<void> | null = null
+  private sessionReplayActions: SessionReplayActions | null = null
+  private sessionReplayInitPromise: Promise<SessionReplayActions> | null = null
 
   constructor(private projectID: string, private options?: LibOptions) {
     this.trackPathChange = this.trackPathChange.bind(this)
     this.heartbeat = this.heartbeat.bind(this)
     this.captureError = this.captureError.bind(this)
+
+    if (this.getSessionReplayPreloadOption()) {
+      void this.preloadSessionReplay().catch(() => undefined)
+    }
   }
 
   captureError(event: ErrorEvent): void {
@@ -370,7 +488,7 @@ export class Lib {
     }
 
     this.pageViewsOptions = options
-    let interval: NodeJS.Timeout
+    let interval: ReturnType<typeof setInterval>
 
     if (!options?.unique) {
       interval = setInterval(this.trackPathChange, 2000)
@@ -431,10 +549,10 @@ export class Lib {
   }
 
   /**
-   * Fetches all feature flags and experiments for the project.
-   * Results are cached for 5 minutes by default.
+   * Fetches all feature flags for the project.
+   * Results are cached for 5 minutes by default and share a cache with experiments.
    *
-   * @param options - Options for evaluating feature flags.
+   * @param options - Options for evaluating feature flags (`profileId` only).
    * @param forceRefresh - If true, bypasses the cache and fetches fresh data.
    * @returns A promise that resolves to a record of flag keys to boolean values.
    */
@@ -512,8 +630,8 @@ export class Lib {
    * Gets the value of a single feature flag.
    *
    * @param key - The feature flag key.
-   * @param options - Options for evaluating the feature flag.
-   * @param defaultValue - Default value to return if the flag is not found. Defaults to false.
+   * @param options - Options for evaluating the feature flag (`profileId` only).
+   * @param defaultValue - Optional default value to return if the flag is not found. Defaults to false.
    * @returns A promise that resolves to the boolean value of the flag.
    */
   async getFeatureFlag(key: string, options?: FeatureFlagsOptions, defaultValue: boolean = false): Promise<boolean> {
@@ -529,16 +647,16 @@ export class Lib {
   }
 
   /**
-   * Fetches all A/B test experiments for the project.
+   * Fetches variant assignments for running A/B test experiments returned by feature flag evaluation.
    * Results are cached for 5 minutes by default (shared cache with feature flags).
    *
-   * @param options - Options for evaluating experiments.
+   * @param options - Options for evaluating experiments (`profileId` only).
    * @param forceRefresh - If true, bypasses the cache and fetches fresh data.
    * @returns A promise that resolves to a record of experiment IDs to variant keys.
    *
    * @example
    * ```typescript
-   * const experiments = await getExperiments()
+   * const experiments = await getExperiments({ profileId: 'user-123' })
    * // experiments = { 'exp-123': 'variant-a', 'exp-456': 'control' }
    * ```
    */
@@ -571,13 +689,16 @@ export class Lib {
    * Gets the variant key for a specific A/B test experiment.
    *
    * @param experimentId - The experiment ID.
-   * @param options - Options for evaluating the experiment.
-   * @param defaultVariant - Default variant key to return if the experiment is not found. Defaults to null.
+   * @param options - Options for evaluating the experiment (`profileId` only).
+   * @param defaultVariant - Optional default variant key to return if the experiment is not found. Defaults to null.
    * @returns A promise that resolves to the variant key assigned to this user, or defaultVariant if not found.
    *
    * @example
    * ```typescript
-   * const variant = await getExperiment('checkout-redesign')
+   * const variant = await getExperiment('checkout-redesign', { profileId: 'user-123' })
+   *
+   * // Optional fallback variant:
+   * const variantWithFallback = await getExperiment('checkout-redesign', undefined, 'control')
    *
    * if (variant === 'new-checkout') {
    *   // Show new checkout flow
@@ -704,6 +825,259 @@ export class Lib {
     }
   }
 
+  async startSessionReplay(
+    options: SessionReplayOptions = {},
+  ): Promise<SessionReplayActions> {
+    if (this.sessionReplayActions) {
+      return this.sessionReplayActions
+    }
+
+    if (this.sessionReplayInitPromise) {
+      return this.sessionReplayInitPromise
+    }
+
+    const initPromise = this.initialiseSessionReplay(options)
+    this.sessionReplayInitPromise = initPromise
+
+    try {
+      return await initPromise
+    } finally {
+      if (this.sessionReplayInitPromise === initPromise) {
+        this.sessionReplayInitPromise = null
+      }
+    }
+  }
+
+  private async initialiseSessionReplay(
+    options: SessionReplayOptions,
+  ): Promise<SessionReplayActions> {
+    if (this.sessionReplayActions) {
+      return this.sessionReplayActions
+    }
+
+    if (!this.canTrack()) {
+      return defaultSessionReplayActions
+    }
+
+    const maxDurationMs =
+      typeof options.maxDurationMs === 'number' && options.maxDurationMs > 0
+        ? options.maxDurationMs
+        : DEFAULT_SESSION_REPLAY_MAX_DURATION_MS
+
+    if (!this.shouldSampleSessionReplay(options.sampleRate)) {
+      return defaultSessionReplayActions
+    }
+
+    try {
+      await this.preloadSessionReplay()
+    } catch {
+      return defaultSessionReplayActions
+    }
+
+    const rrweb = window.rrweb
+    if (!rrweb?.record) {
+      return defaultSessionReplayActions
+    }
+
+    const privacy = this.getSessionReplayPrivacy(options.privacy)
+    const proposedReplayId = this.createReplayId()
+    const started = await this.sendSessionReplayStart(proposedReplayId, privacy)
+
+    if (!started) {
+      return defaultSessionReplayActions
+    }
+
+    const replayId = started.replayId
+
+    const flushIntervalMs =
+      typeof options.flushIntervalMs === 'number' && options.flushIntervalMs > 0
+        ? options.flushIntervalMs
+        : DEFAULT_SESSION_REPLAY_FLUSH_INTERVAL
+    const maxEventsPerChunk =
+      typeof options.maxEventsPerChunk === 'number' &&
+      options.maxEventsPerChunk > 0
+        ? Math.floor(options.maxEventsPerChunk)
+        : DEFAULT_SESSION_REPLAY_MAX_EVENTS
+    const maxBytesPerChunkCandidate =
+      typeof options.maxBytesPerChunk === 'number'
+        ? Math.floor(options.maxBytesPerChunk)
+        : Number.NaN
+    const maxBytesPerChunk =
+      maxBytesPerChunkCandidate >= 1
+        ? maxBytesPerChunkCandidate
+        : DEFAULT_SESSION_REPLAY_MAX_CHUNK_BYTES
+    const maxBytesPerEventCandidate =
+      typeof options.maxBytesPerEvent === 'number'
+        ? Math.floor(options.maxBytesPerEvent)
+        : Number.NaN
+    const maxBytesPerEvent =
+      maxBytesPerEventCandidate >= 1
+        ? maxBytesPerEventCandidate
+        : DEFAULT_SESSION_REPLAY_MAX_EVENT_BYTES
+    const idleTimeoutMs =
+      typeof options.idleTimeoutMs === 'number' && options.idleTimeoutMs > 0
+        ? options.idleTimeoutMs
+        : null
+
+    let chunkIndex = started.nextChunkIndex
+    let stopped = false
+    let events: RrwebEvent[] = []
+    let eventsByteLength = 0
+    let flushing = Promise.resolve()
+    let maxDurationTimer: ReturnType<typeof setTimeout> | undefined
+    let idleTimer: ReturnType<typeof setTimeout> | undefined
+
+    const flush = async (useBeacon = false) => {
+      if (!events.length) return
+
+      const chunk = events
+      events = []
+      eventsByteLength = 0
+      const currentChunkIndex = chunkIndex++
+
+      flushing = flushing
+        .catch(() => undefined)
+        .then(() =>
+          this.sendSessionReplayChunk(
+            replayId,
+            privacy,
+            currentChunkIndex,
+            chunk,
+            useBeacon,
+          ),
+        )
+
+      await flushing
+    }
+
+    const userEmit = options.rrweb?.emit
+    const recordOptions = this.getSessionReplayRecordOptions(
+      privacy,
+      options.rrweb,
+      (event) => {
+        try {
+          userEmit?.(event)
+        } catch {}
+
+        let eventByteLength = 0
+
+        try {
+          eventByteLength = getStringByteLength(JSON.stringify(event))
+        } catch {
+          return
+        }
+
+        if (eventByteLength > maxBytesPerEvent) {
+          return
+        }
+
+        if (
+          events.length &&
+          eventsByteLength + eventByteLength > maxBytesPerChunk
+        ) {
+          void flush()
+        }
+
+        events.push(event)
+        eventsByteLength += eventByteLength
+        if (
+          events.length >= maxEventsPerChunk ||
+          eventsByteLength >= maxBytesPerChunk
+        ) {
+          void flush()
+        }
+      },
+      Boolean(options.recordIframes),
+      options.maskAllText,
+    )
+
+    const stopRecording = rrweb.record(recordOptions)
+    const timer = setInterval(() => void flush(), flushIntervalMs)
+    const flushOnPageExit = () => void flush(true)
+    const flushOnHidden = () => {
+      if (document.visibilityState === 'hidden') {
+        void flush(true)
+      }
+    }
+    const clearIdleTimer = () => {
+      if (idleTimer) {
+        clearTimeout(idleTimer)
+        idleTimer = undefined
+      }
+    }
+    const stopSessionReplay = async () => {
+      if (stopped) return
+      stopped = true
+      clearInterval(timer)
+      if (maxDurationTimer) {
+        clearTimeout(maxDurationTimer)
+      }
+      clearIdleTimer()
+      window.removeEventListener('pagehide', flushOnPageExit)
+      document.removeEventListener('visibilitychange', flushOnHidden)
+      SESSION_REPLAY_ACTIVITY_EVENTS.forEach((eventName) => {
+        window.removeEventListener(eventName, resetIdleTimer)
+      })
+      stopRecording?.()
+      await flush()
+      this.sessionReplayActions = null
+      this.sessionReplayInitPromise = null
+    }
+    const resetIdleTimer = () => {
+      if (!idleTimeoutMs || stopped) return
+      clearIdleTimer()
+      idleTimer = setTimeout(() => void stopSessionReplay(), idleTimeoutMs)
+    }
+
+    window.addEventListener('pagehide', flushOnPageExit)
+    document.addEventListener('visibilitychange', flushOnHidden)
+
+    maxDurationTimer = setTimeout(
+      () => void stopSessionReplay(),
+      maxDurationMs,
+    )
+
+    if (idleTimeoutMs) {
+      SESSION_REPLAY_ACTIVITY_EVENTS.forEach((eventName) => {
+        window.addEventListener(eventName, resetIdleTimer, { passive: true })
+      })
+      resetIdleTimer()
+    }
+
+    this.sessionReplayActions = {
+      stop: stopSessionReplay,
+      flush: async () => {
+        await flush()
+      },
+    }
+
+    return this.sessionReplayActions
+  }
+
+  private shouldSampleSessionReplay(sampleRate?: number): boolean {
+    if (typeof sampleRate !== 'number') {
+      return true
+    }
+
+    if (sampleRate <= 0) {
+      return false
+    }
+
+    if (sampleRate >= 1) {
+      return true
+    }
+
+    return Math.random() < sampleRate
+  }
+
+  private getSessionReplayPrivacy(privacy: unknown): SessionReplayPrivacy {
+    return SESSION_REPLAY_PRIVACY_VALUES.includes(
+      privacy as SessionReplayPrivacy,
+    )
+      ? (privacy as SessionReplayPrivacy)
+      : DEFAULT_SESSION_REPLAY_PRIVACY
+  }
+
   /**
    * Gets the API base URL (without /log suffix).
    */
@@ -812,6 +1186,371 @@ export class Lib {
     return true
   }
 
+  private getSessionReplayUrl(): string {
+    const replayOption = this.getSessionReplayPreloadOption()
+    if (
+      replayOption &&
+      typeof replayOption === 'object' &&
+      replayOption.rrwebUrl
+    ) {
+      return replayOption.rrwebUrl
+    }
+
+    return this.getDefaultSessionReplayUrl()
+  }
+
+  private getSessionReplayPreloadOption(): SessionReplayPreloadOption | undefined {
+    return this.options?.preloadSessionReplay
+  }
+
+  private getDefaultSessionReplayUrl(): string {
+    if (!isInBrowser()) {
+      return DEFAULT_RRWEB_URL
+    }
+
+    const trackerScript = this.getTrackerScript()
+
+    if (trackerScript?.src) {
+      const { hostname, pathname } = new URL(trackerScript.src)
+      if (
+        hostname === 'swetrix.org' &&
+        /^\/swetrix(\.min)?\.js$/i.test(pathname)
+      ) {
+        return DEFAULT_RRWEB_URL
+      }
+
+      return new URL(DEFAULT_RRWEB_FILE, trackerScript.src).toString()
+    }
+
+    return DEFAULT_RRWEB_URL
+  }
+
+  private getTrackerScript(): HTMLScriptElement | undefined {
+    const trackerScript = Array.from(document.scripts).find((script) => {
+      if (!script.src) {
+        return false
+      }
+
+      try {
+        const { pathname } = new URL(script.src)
+        return /(^|\/)swetrix(\.min)?\.js$/i.test(pathname)
+      } catch {
+        return false
+      }
+    })
+
+    return trackerScript
+  }
+
+  private preloadSessionReplay(): Promise<void> {
+    if (!isInBrowser()) {
+      return Promise.resolve()
+    }
+
+    if (window.rrweb?.record) {
+      return Promise.resolve()
+    }
+
+    if (this.rrwebLoader) {
+      return this.rrwebLoader
+    }
+
+    if (window.__SWETRIX_RRWEB_LOADING__) {
+      this.rrwebLoader = window.__SWETRIX_RRWEB_LOADING__
+      void this.rrwebLoader.catch(() => {
+        if (window.__SWETRIX_RRWEB_LOADING__ === this.rrwebLoader) {
+          delete window.__SWETRIX_RRWEB_LOADING__
+        }
+        this.rrwebLoader = null
+      })
+      return this.rrwebLoader
+    }
+
+    this.rrwebLoader = this.loadSessionReplayRecorder()
+
+    window.__SWETRIX_RRWEB_LOADING__ = this.rrwebLoader
+    const loader = this.rrwebLoader
+    void loader.catch(() => {
+      if (window.__SWETRIX_RRWEB_LOADING__ === loader) {
+        delete window.__SWETRIX_RRWEB_LOADING__
+      }
+      if (this.rrwebLoader === loader) {
+        this.rrwebLoader = null
+      }
+    })
+
+    return this.rrwebLoader
+  }
+
+  private async loadSessionReplayRecorder(): Promise<void> {
+    const replayOption = this.getSessionReplayPreloadOption()
+    const hasCustomReplayUrl =
+      replayOption && typeof replayOption === 'object' && replayOption.rrwebUrl
+
+    if (hasCustomReplayUrl || this.getTrackerScript()) {
+      await this.loadSessionReplayScript(this.getSessionReplayUrl())
+      return
+    }
+
+    if (await this.loadSessionReplayPackage()) {
+      return
+    }
+
+    await this.loadSessionReplayScript(this.getDefaultSessionReplayUrl())
+  }
+
+  private async loadSessionReplayPackage(): Promise<boolean> {
+    try {
+      const rrwebModule = (await import('rrweb')) as RrwebModule
+      const rrweb = rrwebModule.record ? rrwebModule : rrwebModule.default
+
+      if (!rrweb?.record) {
+        return false
+      }
+
+      window.rrweb = rrweb
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  private loadSessionReplayScript(url: string): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      const script = document.createElement('script')
+      script.async = true
+      script.src = url
+      script.crossOrigin = 'anonymous'
+      script.onload = () => resolve()
+      script.onerror = () => reject(new Error('Failed to load rrweb'))
+      document.head.appendChild(script)
+    })
+  }
+
+  private getSessionReplayRecordOptions(
+    privacy: unknown,
+    userOptions: RrwebRecordOptions | undefined,
+    emit: RrwebEmit,
+    recordIframes: boolean,
+    maskAllText?: boolean,
+  ): RrwebRecordOptions {
+    const hasUserSampling =
+      userOptions &&
+      Object.prototype.hasOwnProperty.call(userOptions, 'sampling')
+    const hasUserSlimDOMOptions =
+      userOptions &&
+      Object.prototype.hasOwnProperty.call(userOptions, 'slimDOMOptions')
+    const sampling =
+      typeof userOptions?.sampling === 'object' && userOptions.sampling !== null
+        ? {
+            ...DEFAULT_SESSION_REPLAY_SAMPLING,
+            ...(userOptions.sampling as Record<string, unknown>),
+          }
+        : hasUserSampling
+          ? userOptions?.sampling
+          : DEFAULT_SESSION_REPLAY_SAMPLING
+    const slimDOMOptions =
+      typeof userOptions?.slimDOMOptions === 'object' &&
+      userOptions.slimDOMOptions !== null
+        ? {
+            ...DEFAULT_SESSION_REPLAY_SLIM_DOM_OPTIONS,
+            ...(userOptions.slimDOMOptions as Record<string, unknown>),
+          }
+        : hasUserSlimDOMOptions
+          ? userOptions?.slimDOMOptions
+          : DEFAULT_SESSION_REPLAY_SLIM_DOM_OPTIONS
+    const options: RrwebRecordOptions = {
+      recordCanvas: false,
+      recordCrossOriginIframes: false,
+      collectFonts: false,
+      inlineImages: false,
+      ...userOptions,
+      sampling,
+      slimDOMOptions,
+      emit,
+    }
+
+    const maskInputOptions =
+      typeof options.maskInputOptions === 'object' &&
+      options.maskInputOptions !== null
+        ? (options.maskInputOptions as Record<string, unknown>)
+        : {}
+
+    const resolvedPrivacy = this.getSessionReplayPrivacy(privacy)
+    const defaultBlockSelector = recordIframes ? undefined : 'iframe'
+    const resolvedMaskAllText =
+      typeof maskAllText === 'boolean'
+        ? maskAllText
+        : resolvedPrivacy === 'total'
+    const textMaskingOptions = resolvedMaskAllText
+      ? { maskTextSelector: '*' }
+      : {}
+
+    if (resolvedPrivacy === 'total') {
+      return {
+        ...options,
+        ...textMaskingOptions,
+        maskAllInputs: true,
+        blockSelector: this.mergeSelectors(
+          this.mergeSelectors(options.blockSelector, defaultBlockSelector),
+          'img, picture, video, audio, canvas, svg',
+        ),
+        recordCanvas: false,
+        inlineImages: false,
+        emit,
+      }
+    }
+
+    if (resolvedPrivacy === 'normal') {
+      return {
+        ...options,
+        ...textMaskingOptions,
+        maskAllInputs: true,
+        blockSelector: this.mergeSelectors(
+          options.blockSelector,
+          defaultBlockSelector,
+        ),
+        emit,
+      }
+    }
+
+    return {
+      ...options,
+      ...textMaskingOptions,
+      blockSelector: this.mergeSelectors(
+        options.blockSelector,
+        defaultBlockSelector,
+      ),
+      maskInputOptions: {
+        ...maskInputOptions,
+        password: true,
+      },
+      emit,
+    }
+  }
+
+  private mergeSelectors(
+    existing: unknown,
+    required?: string,
+  ): string | undefined {
+    if (!required) {
+      return typeof existing === 'string' ? existing : undefined
+    }
+
+    if (typeof existing === 'string' && existing.trim()) {
+      return `${existing}, ${required}`
+    }
+
+    return required
+  }
+
+  private createReplayId(): string {
+    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
+      return crypto.randomUUID()
+    }
+
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`
+  }
+
+  private async sendSessionReplayStart(
+    replayId: string,
+    privacy: SessionReplayPrivacy,
+  ): Promise<SessionReplayStartResponse | null> {
+    try {
+      const apiBase = this.getApiBase()
+      const response = await fetch(`${apiBase}/log/session-replay/start`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          pid: this.projectID,
+          replayId,
+          privacy,
+          pg:
+            this.activePage ||
+            getPath({
+              hash: this.pageViewsOptions?.hash,
+              search: this.pageViewsOptions?.search,
+            }),
+          lc: getLocale(),
+          tz: getTimezone(),
+          profileId: this.options?.profileId,
+        }),
+      })
+
+      if (!response.ok) {
+        return null
+      }
+
+      try {
+        const result = (await response.json()) as Partial<{
+          replayId: unknown
+          nextChunkIndex: unknown
+        }>
+        const resolvedReplayId =
+          typeof result.replayId === 'string' && result.replayId
+            ? result.replayId
+            : replayId
+        const resolvedChunkIndex =
+          typeof result.nextChunkIndex === 'number' &&
+          Number.isFinite(result.nextChunkIndex) &&
+          result.nextChunkIndex >= 0
+            ? Math.floor(result.nextChunkIndex)
+            : 0
+
+        return {
+          replayId: resolvedReplayId,
+          nextChunkIndex: resolvedChunkIndex,
+        }
+      } catch {
+        return {
+          replayId,
+          nextChunkIndex: 0,
+        }
+      }
+    } catch {
+      return null
+    }
+  }
+
+  private async sendSessionReplayChunk(
+    replayId: string,
+    privacy: SessionReplayPrivacy,
+    chunkIndex: number,
+    events: RrwebEvent[],
+    useBeacon: boolean,
+  ): Promise<void> {
+    const apiBase = this.getApiBase()
+    const url = `${apiBase}/log/session-replay/chunk`
+    const payload = JSON.stringify({
+      pid: this.projectID,
+      replayId,
+      privacy,
+      chunkIndex,
+      events,
+    })
+
+    if (useBeacon && typeof navigator.sendBeacon === 'function') {
+      const sent = navigator.sendBeacon(
+        url,
+        new Blob([payload], { type: 'application/json' }),
+      )
+      if (sent) return
+    }
+
+    try {
+      await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        keepalive: useBeacon,
+        body: payload,
+      })
+    } catch {}
+  }
+
   private async sendRequest(path: string, body: object): Promise<void> {
     const host = this.options?.apiURL || DEFAULT_API_HOST
     await fetch(`${host}/${path}`, {