@kubesense/kubesense-browser-rum-core 1.8.0 → 2.0.0-beta.1

package/src/transport/formDataTransport.ts

@@ -3,10 +3,18 @@ import type {
   Encoder,
   EncoderResult,
   DeflateEncoderStreamId,
-  RawError,
   Context,
 } from '@kubesense/kubesense-browser-core'
-import { addTelemetryDebug, createHttpRequest, jsonStringify, objectEntries } from '@kubesense/kubesense-browser-core'
+import {
+  addTelemetryDebug,
+  createHttpRequest,
+  jsonStringify,
+  objectEntries,
+  ErrorSource,
+  DEFAULT_ERROR_TYPE,
+} from '@kubesense/kubesense-browser-core'
+import { clocksNow } from '@kubesense/kubesense-js-core/time'
+import { createEndpointBuilder } from '@kubesense/kubesense-js-core/transport'
 import type { RumConfiguration } from '../domain/configuration'
 import type { LifeCycle } from '../domain/lifeCycle'
 import { LifeCycleEventType } from '../domain/lifeCycle'
@@ -29,14 +37,16 @@ export function createFormDataTransport<T extends TransportPayload>(
   createEncoder: (streamId: DeflateEncoderStreamId) => Encoder,
   streamId: DeflateEncoderStreamId
 ) {
-  const reportError = (error: RawError) => {
-    lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, { error })
+  const reportError = (message: string) => {
+    lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, {
+      error: { message, type: DEFAULT_ERROR_TYPE, source: ErrorSource.AGENT, startClocks: clocksNow() },
+    })
 
     // monitor-until: forever, to keep an eye on the errors reported to customers
-    addTelemetryDebug('Error reported to customer', { 'error.message': error.message })
+    addTelemetryDebug('Error reported to customer', { 'error.message': message })
   }
 
-  const httpRequest = createHttpRequest([configuration.profilingEndpointBuilder], reportError)
+  const httpRequest = createHttpRequest([createEndpointBuilder(configuration, 'profile')], reportError)
 
   const encoder = createEncoder(streamId)
 

package/src/transport/startRumBatch.ts

@@ -1,46 +1,203 @@
-import type { Observable, RawError, PageMayExitEvent, Encoder } from '@kubesense/kubesense-browser-core'
-import { createBatch, createFlushController, createHttpRequest, DeflateEncoderStreamId } from '@kubesense/kubesense-browser-core'
+import type { Observable, Encoder, Context } from '@kubesense/kubesense-browser-core'
+import { createBatch, DeflateEncoderStreamId, sendToExtension } from '@kubesense/kubesense-browser-core'
+import { combine } from '@kubesense/kubesense-js-core/util'
+import { createEndpointBuilder, createReplicaEndpointBuilder } from '@kubesense/kubesense-js-core/transport'
 import type { RumConfiguration } from '../domain/configuration'
 import type { LifeCycle } from '../domain/lifeCycle'
 import { LifeCycleEventType } from '../domain/lifeCycle'
 import type { AssembledRumEvent } from '../rawRumEvent.types'
+import type { RumViewEvent, RumViewUpdateEvent } from '../rumEvent.types'
 import { RumEventType } from '../rawRumEvent.types'
+import { diffMerge } from '../domain/view/viewDiff'
+
+export const PARTIAL_VIEW_UPDATE_CHECKPOINT_INTERVAL = 100
+
+export type AssembledViewDiff = Omit<RumViewUpdateEvent, 'view' | '_kubesense'> & {
+  view: Partial<RumViewEvent['view']> & { id: string; url: string }
+  _kubesense?: { document_version: number; format_version: number; [k: string]: unknown }
+}
+
+export function computeAssembledViewDiff(current: RumViewEvent, last: RumViewEvent): AssembledViewDiff | undefined {
+  const diff = diffMerge(current, last, {
+    // context, connectivity, usr, device, privacy are objects — use REPLACE to avoid partial updates
+    replaceKeys: new Set(['view.custom_timings', 'context', 'connectivity', 'usr', 'device', 'privacy']),
+    appendKeys: new Set(['_kubesense.page_states']),
+    // Ignore always-required fields — they are added back via combine regardless of changes
+    ignoreKeys: new Set([
+      'date',
+      'type',
+      'application',
+      'session',
+      'view.id',
+      'view.url',
+      '_kubesense.document_version',
+      '_kubesense.format_version',
+    ]),
+  })
+
+  if (!diff) {
+    return undefined
+  }
+
+  // Merge always-required fields on top of the diff for backend routing
+  return combine(diff, {
+    type: RumEventType.VIEW_UPDATE,
+    date: current.date,
+    application: current.application,
+    session: current.session,
+    view: {
+      id: current.view.id,
+      url: current.view.url,
+    },
+    _kubesense: {
+      document_version: current._kubesense.document_version,
+      format_version: current._kubesense.format_version,
+    },
+  })
+}
+
+/**
+ * Dispatches assembled RUM events to the batch. VIEW events are handled specially:
+ * intermediate updates either replace the full VIEW already in the batch, or are
+ * aggregated into a single view_update diff against the last flushed state.
+ */
+export function createBatchDispatcher(
+  batch: Pick<ReturnType<typeof createBatch>, 'flushObservable' | 'isEmpty' | 'add' | 'upsert'>,
+  enableViewUpdates: boolean
+): { dispatch: (event: AssembledRumEvent) => void; stop: () => void } {
+  let lastSentView: RumViewEvent | undefined
+  // Base used to compute the aggregate diff for the current batch's view_update.
+  // Reset to lastSentView on each flush (= what the backend received in the previous batch).
+  let batchBase: RumViewEvent | undefined
+  // True when the current batch already contains a full VIEW event for the active view.
+  // Reset to false on each flush.
+  let batchHasFullView = false
+  let viewUpdatesSinceCheckpoint = 0
+
+  // On flush: advance batchBase to lastSentView (what the backend now has) and clear the flag.
+  // lastSentView is set AFTER batch.upsert() in the new-view and checkpoint paths so that if
+  // upsert() triggers a sync flush, the subscriber captures the previous view (what the backend
+  // actually received), not the one being added.
+  const { unsubscribe } = batch.flushObservable.subscribe(() => {
+    batchHasFullView = false
+    batchBase = lastSentView
+  })
+
+  return {
+    dispatch: (serverRumEvent: AssembledRumEvent) => {
+      if (serverRumEvent.type !== RumEventType.VIEW) {
+        // Non-view events: always append
+        batch.add(serverRumEvent)
+        return
+      }
+
+      if (!enableViewUpdates) {
+        // Feature OFF: existing behavior — upsert full view
+        batch.upsert(serverRumEvent, serverRumEvent.view.id)
+        return
+      }
+
+      const viewId = serverRumEvent.view.id
+
+      // View ended (is_active: false) — always send a full VIEW.
+      // Checked before the new-view guard so that a stale view-end for an old view
+      // (arriving after a new view has already started) is handled correctly: we upsert
+      // it without touching the state of the current view.
+      if (!serverRumEvent.view.is_active) {
+        if (viewId === lastSentView?.view.id) {
+          // Current view ended — reset all state
+          lastSentView = undefined
+          batchBase = undefined
+          batchHasFullView = false
+          viewUpdatesSinceCheckpoint = 0
+        }
+        batch.upsert(serverRumEvent, viewId)
+        return
+      }
+
+      // New view started
+      if (viewId !== lastSentView?.view.id) {
+        viewUpdatesSinceCheckpoint = 0
+        batch.upsert(serverRumEvent, viewId)
+        // lastSentView set AFTER upsert: if upsert triggers a sync flush, the subscriber
+        // captures the old lastSentView as batchBase (what the backend actually received),
+        // not the new view that hasn't been sent yet.
+        lastSentView = serverRumEvent
+        // If upsert triggered an after-add flush (e.g. messages_limit), the VIEW was sent
+        // and the batch is now empty — isEmpty is true. Otherwise the VIEW is in the batch.
+        batchHasFullView = !batch.isEmpty
+        return
+      }
+
+      // Intermediate update
+      lastSentView = serverRumEvent
+
+      if (batchHasFullView) {
+        // Optimization 1: batch already has a full VIEW — replace it with the latest full view.
+        // This is equivalent to the non-experimental upsert behavior for in-flight batches.
+        batch.upsert(serverRumEvent, viewId)
+        return
+      }
+
+      // Optimization 2: no full VIEW in the current batch — compute an aggregate diff from
+      // batchBase (last state the backend received) and upsert it under the same key as the VIEW.
+      // Each update replaces the previous aggregate, so the batch always contains at most one
+      // view_update per view ID.
+      //
+      // Note: view_update events are created here, post-assembly, bypassing
+      // RAW_RUM_EVENT_COLLECTED → assembly → RUM_EVENT_COLLECTED. They intentionally skip
+      // beforeSend — view_update is an internal bandwidth optimization, not a customer-visible type.
+
+      // Checkpoint: periodically send a full VIEW for backend reliability.
+      // When the checkpoint fires, upsert(VIEW) replaces any pending view_update (same key).
+      viewUpdatesSinceCheckpoint += 1
+      if (viewUpdatesSinceCheckpoint >= PARTIAL_VIEW_UPDATE_CHECKPOINT_INTERVAL) {
+        viewUpdatesSinceCheckpoint = 0
+        batch.upsert(serverRumEvent, viewId)
+        batchHasFullView = !batch.isEmpty
+        return
+      }
+
+      if (batchBase) {
+        const diff = computeAssembledViewDiff(serverRumEvent, batchBase)
+        if (diff) {
+          sendToExtension('rum', diff)
+          batch.upsert(diff as unknown as Context, viewId)
+        }
+      }
+    },
+    stop: unsubscribe,
+  }
+}
 
 export function startRumBatch(
   configuration: RumConfiguration,
   lifeCycle: LifeCycle,
-  reportError: (error: RawError) => void,
-  pageMayExitObservable: Observable<PageMayExitEvent>,
+  reportError: (message: string) => void,
   sessionExpireObservable: Observable<void>,
   createEncoder: (streamId: DeflateEncoderStreamId) => Encoder
 ) {
-  const endpoints = [configuration.rumEndpointBuilder]
-  if (configuration.replica) {
-    endpoints.push(configuration.replica.rumEndpointBuilder)
+  const endpoints = [createEndpointBuilder(configuration, 'rum')]
+  const replicaEndpoint = createReplicaEndpointBuilder(configuration, 'rum')
+  if (replicaEndpoint) {
+    endpoints.push(replicaEndpoint)
   }
 
-  const request = createHttpRequest(endpoints, reportError)
-
   const batch = createBatch({
     encoder: createEncoder(DeflateEncoderStreamId.RUM),
-    request,
-    flushController: createFlushController({
-      pageMayExitObservable,
-      sessionExpireObservable,
-    }),
+    endpoints,
+    reportError,
   })
+  sessionExpireObservable.subscribe(() => batch.forceFlush('session_expire'))
 
-  pageMayExitObservable.subscribe(() => {
-    request.sendQueuedOnExit()
-  })
+  const { dispatch, stop: stopDispatcher } = createBatchDispatcher(batch, configuration.betaEnableViewUpdates)
+  lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, dispatch)
 
-  lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (serverRumEvent: AssembledRumEvent) => {
-    if (serverRumEvent.type === RumEventType.VIEW) {
-      batch.upsert(serverRumEvent, serverRumEvent.view.id)
-    } else {
-      batch.add(serverRumEvent)
-    }
-  })
+  const stopBatch = batch.stop.bind(batch)
+  batch.stop = () => {
+    stopDispatcher()
+    stopBatch()
+  }
 
   return batch
 }

package/cjs/browser/firstInputPolyfill.d.ts

@@ -1,8 +0,0 @@
-import type { RumConfiguration } from '../domain/configuration';
-/**
- * first-input timing entry polyfill based on
- * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts
- */
-export declare function retrieveFirstInputTiming(configuration: RumConfiguration, callback: (timing: PerformanceEventTiming) => void): {
-    stop: () => void;
-};

package/cjs/browser/firstInputPolyfill.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveFirstInputTiming = retrieveFirstInputTiming;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-/**
- * first-input timing entry polyfill based on
- * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts
- */
-function retrieveFirstInputTiming(configuration, callback) {
-    const startTimeStamp = (0, kubesense_browser_core_1.dateNow)();
-    let timingSent = false;
-    const { stop: removeEventListeners } = (0, kubesense_browser_core_1.addEventListeners)(configuration, window, ["click" /* DOM_EVENT.CLICK */, "mousedown" /* DOM_EVENT.MOUSE_DOWN */, "keydown" /* DOM_EVENT.KEY_DOWN */, "touchstart" /* DOM_EVENT.TOUCH_START */, "pointerdown" /* DOM_EVENT.POINTER_DOWN */], (evt) => {
-        // Only count cancelable events, which should trigger behavior important to the user.
-        if (!evt.cancelable) {
-            return;
-        }
-        // This timing will be used to compute the "first Input delay", which is the delta between
-        // when the system received the event (e.g. evt.timeStamp) and when it could run the callback
-        // (e.g. performance.now()).
-        const timing = {
-            entryType: 'first-input',
-            processingStart: (0, kubesense_browser_core_1.relativeNow)(),
-            processingEnd: (0, kubesense_browser_core_1.relativeNow)(),
-            startTime: evt.timeStamp,
-            duration: 0, // arbitrary value to avoid nullable duration and simplify INP logic
-            name: '',
-            cancelable: false,
-            target: null,
-            toJSON: () => ({}),
-        };
-        if (evt.type === "pointerdown" /* DOM_EVENT.POINTER_DOWN */) {
-            sendTimingIfPointerIsNotCancelled(configuration, timing);
-        }
-        else {
-            sendTiming(timing);
-        }
-    }, { passive: true, capture: true });
-    return { stop: removeEventListeners };
-    /**
-     * Pointer events are a special case, because they can trigger main or compositor thread behavior.
-     * We differentiate these cases based on whether or not we see a pointercancel event, which are
-     * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes
-     * scrolling and pinch/zooming.
-     */
-    function sendTimingIfPointerIsNotCancelled(configuration, timing) {
-        (0, kubesense_browser_core_1.addEventListeners)(configuration, window, ["pointerup" /* DOM_EVENT.POINTER_UP */, "pointercancel" /* DOM_EVENT.POINTER_CANCEL */], (event) => {
-            if (event.type === "pointerup" /* DOM_EVENT.POINTER_UP */) {
-                sendTiming(timing);
-            }
-        }, { once: true });
-    }
-    function sendTiming(timing) {
-        if (!timingSent) {
-            timingSent = true;
-            removeEventListeners();
-            // In some cases the recorded delay is clearly wrong, e.g. it's negative or it's larger than
-            // the time between now and when the page was loaded.
-            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4
-            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6
-            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7
-            const delay = timing.processingStart - timing.startTime;
-            if (delay >= 0 && delay < (0, kubesense_browser_core_1.dateNow)() - startTimeStamp) {
-                callback(timing);
-            }
-        }
-    }
-}
-//# sourceMappingURL=firstInputPolyfill.js.map

package/cjs/browser/firstInputPolyfill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"firstInputPolyfill.js","sourceRoot":"","sources":["../../src/browser/firstInputPolyfill.ts"],"names":[],"mappings":";;AAQA,4DA8EC;AArFD,8EAAsG;AAGtG;;;GAGG;AACH,SAAgB,wBAAwB,CACtC,aAA+B,EAC/B,QAAkD;IAElD,MAAM,cAAc,GAAG,IAAA,gCAAO,GAAE,CAAA;IAChC,IAAI,UAAU,GAAG,KAAK,CAAA;IAEtB,MAAM,EAAE,IAAI,EAAE,oBAAoB,EAAE,GAAG,IAAA,0CAAiB,EACtD,aAAa,EACb,MAAM,EACN,iMAA0G,EAC1G,CAAC,GAAG,EAAE,EAAE;QACN,qFAAqF;QACrF,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC;YACpB,OAAM;QACR,CAAC;QAED,0FAA0F;QAC1F,6FAA6F;QAC7F,4BAA4B;QAC5B,MAAM,MAAM,GAA2B;YACrC,SAAS,EAAE,aAAa;YACxB,eAAe,EAAE,IAAA,oCAAW,GAAE;YAC9B,aAAa,EAAE,IAAA,oCAAW,GAAE;YAC5B,SAAS,EAAE,GAAG,CAAC,SAAyB;YACxC,QAAQ,EAAE,CAAa,EAAE,oEAAoE;YAC7F,IAAI,EAAE,EAAE;YACR,UAAU,EAAE,KAAK;YACjB,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;SACnB,CAAA;QAED,IAAI,GAAG,CAAC,IAAI,+CAA2B,EAAE,CAAC;YACxC,iCAAiC,CAAC,aAAa,EAAE,MAAM,CAAC,CAAA;QAC1D,CAAC;aAAM,CAAC;YACN,UAAU,CAAC,MAAM,CAAC,CAAA;QACpB,CAAC;IACH,CAAC,EACD,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CACjC,CAAA;IAED,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAA;IAErC;;;;;OAKG;IACH,SAAS,iCAAiC,CAAC,aAA+B,EAAE,MAA8B;QACxG,IAAA,0CAAiB,EACf,aAAa,EACb,MAAM,EACN,wFAAgD,EAChD,CAAC,KAAK,EAAE,EAAE;YACR,IAAI,KAAK,CAAC,IAAI,2CAAyB,EAAE,CAAC;gBACxC,UAAU,CAAC,MAAM,CAAC,CAAA;YACpB,CAAC;QACH,CAAC,EACD,EAAE,IAAI,EAAE,IAAI,EAAE,CACf,CAAA;IACH,CAAC;IAED,SAAS,UAAU,CAAC,MAA8B;QAChD,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,UAAU,GAAG,IAAI,CAAA;YACjB,oBAAoB,EAAE,CAAA;YACtB,4FAA4F;YAC5F,qDAAqD;YACrD,mEAAmE;YACnE,mEAAmE;YACnE,mEAAmE;YACnE,MAAM,KAAK,GAAG,MAAM,CAAC,eAAe,GAAG,MAAM,CAAC,SAAS,CAAA;YACvD,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,GAAG,IAAA,gCAAO,GAAE,GAAG,cAAc,EAAE,CAAC;gBACrD,QAAQ,CAAC,MAAM,CAAC,CAAA;YAClB,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC"}

package/cjs/domain/configuration/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/domain/configuration/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAA+B;AAC/B,wDAAqC;AACrC,2DAAwC;AACxC,wDAAqC"}

package/cjs/domain/configuration/remoteConfiguration.types.js

@@ -1,7 +0,0 @@
-"use strict";
-/* eslint-disable */
-/**
- * DO NOT MODIFY IT BY HAND. Run `yarn json-schemas:sync` instead.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=remoteConfiguration.types.js.map

package/cjs/domain/configuration/remoteConfiguration.types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"remoteConfiguration.types.js","sourceRoot":"","sources":["../../../src/domain/configuration/remoteConfiguration.types.ts"],"names":[],"mappings":";AAAA,oBAAoB;AACpB;;GAEG"}

package/cjs/domain/error/trackConsoleError.d.ts

@@ -1,4 +0,0 @@
-import type { Observable, RawError } from '@kubesense/kubesense-browser-core';
-export declare function trackConsoleError(errorObservable: Observable<RawError>): {
-    stop: () => void;
-};

package/cjs/domain/error/trackConsoleError.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackConsoleError = trackConsoleError;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-function trackConsoleError(errorObservable) {
-    const subscription = (0, kubesense_browser_core_1.initConsoleObservable)([kubesense_browser_core_1.ConsoleApiName.error]).subscribe((consoleLog) => errorObservable.notify(consoleLog.error));
-    return {
-        stop: () => {
-            subscription.unsubscribe();
-        },
-    };
-}
-//# sourceMappingURL=trackConsoleError.js.map

package/cjs/domain/error/trackConsoleError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"trackConsoleError.js","sourceRoot":"","sources":["../../../src/domain/error/trackConsoleError.ts"],"names":[],"mappings":";;AAGA,8CAUC;AAZD,8EAAyF;AAEzF,SAAgB,iBAAiB,CAAC,eAAqC;IACrE,MAAM,YAAY,GAAG,IAAA,8CAAqB,EAAC,CAAC,uCAAc,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,EAAE,CAC1F,eAAe,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CACzC,CAAA;IAED,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,YAAY,CAAC,WAAW,EAAE,CAAA;QAC5B,CAAC;KACF,CAAA;AACH,CAAC"}

package/cjs/domain/resource/matchRequestResourceEntry.d.ts

@@ -1,16 +0,0 @@
-import type { RumPerformanceResourceTiming } from '../../browser/performanceObservable';
-import type { RequestCompleteEvent } from '../requestCollection';
-/**
- * Look for corresponding timing in resource timing buffer
- *
- * Observations:
- * - Timing (start, end) are nested inside the request (start, end)
- * - Some timing can be not exactly nested, being off by < 1 ms
- *
- * Strategy:
- * - from valid nested entries (with 1 ms error margin)
- * - filter out timing that were already matched to a request
- * - then, if a single timing match, return the timing
- * - otherwise we can't decide, return undefined
- */
-export declare function matchRequestResourceEntry(request: RequestCompleteEvent): RumPerformanceResourceTiming | undefined;

package/cjs/domain/resource/matchRequestResourceEntry.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchRequestResourceEntry = matchRequestResourceEntry;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const resourceUtils_1 = require("./resourceUtils");
-const alreadyMatchedEntries = new WeakSet();
-/**
- * Look for corresponding timing in resource timing buffer
- *
- * Observations:
- * - Timing (start, end) are nested inside the request (start, end)
- * - Some timing can be not exactly nested, being off by < 1 ms
- *
- * Strategy:
- * - from valid nested entries (with 1 ms error margin)
- * - filter out timing that were already matched to a request
- * - then, if a single timing match, return the timing
- * - otherwise we can't decide, return undefined
- */
-function matchRequestResourceEntry(request) {
-    if (!performance || !('getEntriesByName' in performance)) {
-        return;
-    }
-    const sameNameEntries = performance.getEntriesByName(request.url, 'resource');
-    if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {
-        return;
-    }
-    const candidates = sameNameEntries
-        .filter((entry) => !alreadyMatchedEntries.has(entry))
-        // Only require valid duration — needed for the isBetween time-window check.
-        // hasValidResourceEntryTimings is intentionally NOT used here: cached resources often have
-        // timing fields zeroed out (browser behaviour) even though their duration and start time
-        // are correct and the entry should still be matched to its request.
-        .filter((entry) => (0, resourceUtils_1.hasValidResourceEntryDuration)(entry))
-        .filter((entry) => isBetween(entry, request.startClocks.relative, endTime({ startTime: request.startClocks.relative, duration: request.duration })));
-    if (candidates.length === 1) {
-        alreadyMatchedEntries.add(candidates[0]);
-        return candidates[0].toJSON();
-    }
-    return;
-}
-function endTime(timing) {
-    return (0, kubesense_browser_core_1.addDuration)(timing.startTime, timing.duration);
-}
-function isBetween(timing, start, end) {
-    const errorMargin = 1;
-    return timing.startTime >= start - errorMargin && endTime(timing) <= (0, kubesense_browser_core_1.addDuration)(end, errorMargin);
-}
-//# sourceMappingURL=matchRequestResourceEntry.js.map

package/cjs/domain/resource/matchRequestResourceEntry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"matchRequestResourceEntry.js","sourceRoot":"","sources":["../../../src/domain/resource/matchRequestResourceEntry.ts"],"names":[],"mappings":";;AA0BA,8DAgCC;AAzDD,8EAA+D;AAG/D,mDAA+D;AAO/D,MAAM,qBAAqB,GAAG,IAAI,OAAO,EAAoB,CAAA;AAE7D;;;;;;;;;;;;GAYG;AACH,SAAgB,yBAAyB,CAAC,OAA6B;IACrE,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,kBAAkB,IAAI,WAAW,CAAC,EAAE,CAAC;QACzD,OAAM;IACR,CAAC;IACD,MAAM,eAAe,GAAG,WAAW,CAAC,gBAAgB,CAAC,OAAO,CAAC,GAAG,EAAE,UAAU,CAAmC,CAAA;IAE/G,IAAI,CAAC,eAAe,CAAC,MAAM,IAAI,CAAC,CAAC,QAAQ,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACjE,OAAM;IACR,CAAC;IAED,MAAM,UAAU,GAAG,eAAe;SAC/B,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,qBAAqB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACrD,4EAA4E;QAC5E,2FAA2F;QAC3F,yFAAyF;QACzF,oEAAoE;SACnE,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,6CAA6B,EAAC,KAAK,CAAC,CAAC;SACvD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAChB,SAAS,CACP,KAAK,EACL,OAAO,CAAC,WAAW,CAAC,QAAQ,EAC5B,OAAO,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CACjF,CACF,CAAA;IAEH,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,qBAAqB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;QAExC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,EAAkC,CAAA;IAC/D,CAAC;IAED,OAAM;AACR,CAAC;AAED,SAAS,OAAO,CAAC,MAAc;IAC7B,OAAO,IAAA,oCAAW,EAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;AACvD,CAAC;AAED,SAAS,SAAS,CAAC,MAAc,EAAE,KAAmB,EAAE,GAAiB;IACvE,MAAM,WAAW,GAAG,CAAa,CAAA;IACjC,OAAO,MAAM,CAAC,SAAS,IAAI,KAAK,GAAG,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,IAAA,oCAAW,EAAC,GAAG,EAAE,WAAW,CAAC,CAAA;AACpG,CAAC"}

package/cjs/domain/resource/retrieveInitialDocumentResourceTiming.d.ts

@@ -1,4 +0,0 @@
-import type { RumPerformanceResourceTiming } from '../../browser/performanceObservable';
-import type { RumConfiguration } from '../configuration';
-import { getNavigationEntry } from '../../browser/performanceUtils';
-export declare function retrieveInitialDocumentResourceTiming(configuration: RumConfiguration, callback: (timing: RumPerformanceResourceTiming) => void, getNavigationEntryImpl?: typeof getNavigationEntry): void;

package/cjs/domain/resource/retrieveInitialDocumentResourceTiming.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveInitialDocumentResourceTiming = retrieveInitialDocumentResourceTiming;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const performanceObservable_1 = require("../../browser/performanceObservable");
-const getDocumentTraceId_1 = require("../tracing/getDocumentTraceId");
-const performanceUtils_1 = require("../../browser/performanceUtils");
-const resourceUtils_1 = require("./resourceUtils");
-function retrieveInitialDocumentResourceTiming(configuration, callback, getNavigationEntryImpl = performanceUtils_1.getNavigationEntry) {
-    (0, kubesense_browser_core_1.runOnReadyState)(configuration, 'interactive', () => {
-        const navigationEntry = getNavigationEntryImpl();
-        const entry = Object.assign(navigationEntry.toJSON(), {
-            entryType: performanceObservable_1.RumPerformanceEntryType.RESOURCE,
-            initiatorType: resourceUtils_1.FAKE_INITIAL_DOCUMENT,
-            // The ResourceTiming duration entry should be `responseEnd - startTime`. With
-            // NavigationTiming entries, `startTime` is always 0, so set it to `responseEnd`.
-            duration: navigationEntry.responseEnd,
-            traceId: (0, getDocumentTraceId_1.getDocumentTraceId)(document),
-            toJSON: () => ({ ...entry, toJSON: undefined }),
-        });
-        callback(entry);
-    });
-}
-//# sourceMappingURL=retrieveInitialDocumentResourceTiming.js.map

package/cjs/domain/resource/retrieveInitialDocumentResourceTiming.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"retrieveInitialDocumentResourceTiming.js","sourceRoot":"","sources":["../../../src/domain/resource/retrieveInitialDocumentResourceTiming.ts"],"names":[],"mappings":";;AAQA,sFAkBC;AA1BD,8EAAmE;AACnE,+EAA6E;AAG7E,sEAAkE;AAClE,qEAAmE;AACnE,mDAAuD;AAEvD,SAAgB,qCAAqC,CACnD,aAA+B,EAC/B,QAAwD,EACxD,sBAAsB,GAAG,qCAAkB;IAE3C,IAAA,wCAAe,EAAC,aAAa,EAAE,aAAa,EAAE,GAAG,EAAE;QACjD,MAAM,eAAe,GAAG,sBAAsB,EAAE,CAAA;QAChD,MAAM,KAAK,GAAiC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,EAAE;YAClF,SAAS,EAAE,+CAAuB,CAAC,QAAiB;YACpD,aAAa,EAAE,qCAAqB;YACpC,8EAA8E;YAC9E,iFAAiF;YACjF,QAAQ,EAAE,eAAe,CAAC,WAAW;YACrC,OAAO,EAAE,IAAA,uCAAkB,EAAC,QAAQ,CAAC;YACrC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;SAChD,CAAC,CAAA;QACF,QAAQ,CAAC,KAAK,CAAC,CAAA;IACjB,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/cjs/domain/rumSessionManager.d.ts

@@ -1,36 +0,0 @@
-import type { RelativeTime, TrackingConsentState } from '@kubesense/kubesense-browser-core';
-import { Observable } from '@kubesense/kubesense-browser-core';
-import type { RumConfiguration } from './configuration';
-import type { LifeCycle } from './lifeCycle';
-export declare const enum SessionType {
-    SYNTHETICS = "synthetics",
-    USER = "user",
-    CI_TEST = "ci_test"
-}
-export declare const RUM_SESSION_KEY = "rum";
-export interface RumSessionManager {
-    findTrackedSession: (startTime?: RelativeTime) => RumSession | undefined;
-    expire: () => void;
-    expireObservable: Observable<void>;
-    setForcedReplay: () => void;
-}
-export interface RumSession {
-    id: string;
-    sessionReplay: SessionReplayState;
-    anonymousId?: string;
-}
-export declare const enum RumTrackingType {
-    NOT_TRACKED = "0",
-    TRACKED_WITH_SESSION_REPLAY = "1",
-    TRACKED_WITHOUT_SESSION_REPLAY = "2"
-}
-export declare const enum SessionReplayState {
-    OFF = 0,
-    SAMPLED = 1,
-    FORCED = 2
-}
-export declare function startRumSessionManager(configuration: RumConfiguration, lifeCycle: LifeCycle, trackingConsentState: TrackingConsentState): RumSessionManager;
-/**
- * Start a tracked replay session stub
- */
-export declare function startRumSessionManagerStub(): RumSessionManager;

package/cjs/domain/rumSessionManager.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RUM_SESSION_KEY = void 0;
-exports.startRumSessionManager = startRumSessionManager;
-exports.startRumSessionManagerStub = startRumSessionManagerStub;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-exports.RUM_SESSION_KEY = 'rum';
-function startRumSessionManager(configuration, lifeCycle, trackingConsentState) {
-    const sessionManager = (0, kubesense_browser_core_1.startSessionManager)(configuration, exports.RUM_SESSION_KEY, (rawTrackingType) => computeTrackingType(configuration, rawTrackingType), trackingConsentState);
-    sessionManager.expireObservable.subscribe(() => {
-        lifeCycle.notify(9 /* LifeCycleEventType.SESSION_EXPIRED */);
-    });
-    sessionManager.renewObservable.subscribe(() => {
-        lifeCycle.notify(10 /* LifeCycleEventType.SESSION_RENEWED */);
-    });
-    sessionManager.sessionStateUpdateObservable.subscribe(({ previousState, newState }) => {
-        if (!previousState.forcedReplay && newState.forcedReplay) {
-            const sessionEntity = sessionManager.findSession();
-            if (sessionEntity) {
-                sessionEntity.isReplayForced = true;
-            }
-        }
-    });
-    return {
-        findTrackedSession: (startTime) => {
-            const session = sessionManager.findSession(startTime);
-            if (!session || session.trackingType === "0" /* RumTrackingType.NOT_TRACKED */) {
-                return;
-            }
-            return {
-                id: session.id,
-                sessionReplay: session.trackingType === "1" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */
-                    ? 1 /* SessionReplayState.SAMPLED */
-                    : session.isReplayForced
-                        ? 2 /* SessionReplayState.FORCED */
-                        : 0 /* SessionReplayState.OFF */,
-                anonymousId: session.anonymousId,
-            };
-        },
-        expire: sessionManager.expire,
-        expireObservable: sessionManager.expireObservable,
-        setForcedReplay: () => sessionManager.updateSessionState({ forcedReplay: '1' }),
-    };
-}
-/**
- * Start a tracked replay session stub
- */
-function startRumSessionManagerStub() {
-    const session = {
-        id: '00000000-aaaa-0000-aaaa-000000000000',
-        sessionReplay: (0, kubesense_browser_core_1.bridgeSupports)("records" /* BridgeCapability.RECORDS */) ? 1 /* SessionReplayState.SAMPLED */ : 0 /* SessionReplayState.OFF */,
-    };
-    return {
-        findTrackedSession: () => session,
-        expire: kubesense_browser_core_1.noop,
-        expireObservable: new kubesense_browser_core_1.Observable(),
-        setForcedReplay: kubesense_browser_core_1.noop,
-    };
-}
-function computeTrackingType(configuration, rawTrackingType) {
-    if (hasValidRumSession(rawTrackingType)) {
-        return rawTrackingType;
-    }
-    if (!(0, kubesense_browser_core_1.performDraw)(configuration.sessionSampleRate)) {
-        return "0" /* RumTrackingType.NOT_TRACKED */;
-    }
-    if (!(0, kubesense_browser_core_1.performDraw)(configuration.sessionReplaySampleRate)) {
-        return "2" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */;
-    }
-    return "1" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */;
-}
-function hasValidRumSession(trackingType) {
-    return (trackingType === "0" /* RumTrackingType.NOT_TRACKED */ ||
-        trackingType === "1" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */ ||
-        trackingType === "2" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */);
-}
-//# sourceMappingURL=rumSessionManager.js.map

package/cjs/domain/rumSessionManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rumSessionManager.js","sourceRoot":"","sources":["../../src/domain/rumSessionManager.ts"],"names":[],"mappings":"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"}

package/cjs/domain/sampler/sampler.d.ts

@@ -1,10 +0,0 @@
-export declare function isSampled(sessionId: string, sampleRate: number): boolean;
-export declare function resetSampleDecisionCache(): void;
-/**
- * Perform sampling using the Knuth factor method. This method offer consistent sampling result
- * based on the provided identifier.
- *
- * @param identifier - The identifier to use for sampling.
- * @param sampleRate - The sample rate in percentage between 0 and 100.
- */
-export declare function sampleUsingKnuthFactor(identifier: bigint, sampleRate: number): boolean;