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

package/cjs/transport/formDataTransport.js

@@ -1,46 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFormDataTransport = createFormDataTransport;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+require("../domain/lifeCycle.js");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_transport = require("@kubesense/kubesense-js-core/transport");
+//#region src/transport/formDataTransport.ts
 function createFormDataTransport(configuration, lifeCycle, createEncoder, streamId) {
-    const reportError = (error) => {
-        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error });
-        // monitor-until: forever, to keep an eye on the errors reported to customers
-        (0, kubesense_browser_core_1.addTelemetryDebug)('Error reported to customer', { 'error.message': error.message });
-    };
-    const httpRequest = (0, kubesense_browser_core_1.createHttpRequest)([configuration.profilingEndpointBuilder], reportError);
-    const encoder = createEncoder(streamId);
-    return {
-        async send({ event, ...attachments }) {
-            const formData = new FormData();
-            const serializedEvent = (0, kubesense_browser_core_1.jsonStringify)(event);
-            if (!serializedEvent) {
-                throw new Error('Failed to serialize event');
-            }
-            formData.append('event', new Blob([serializedEvent], { type: 'application/json' }), 'event.json');
-            let bytesCount = serializedEvent.length;
-            for (const [key, value] of (0, kubesense_browser_core_1.objectEntries)(attachments)) {
-                const serializedValue = (0, kubesense_browser_core_1.jsonStringify)(value);
-                if (!serializedValue) {
-                    throw new Error('Failed to serialize attachment');
-                }
-                const result = await encode(encoder, serializedValue);
-                bytesCount += result.outputBytesCount;
-                formData.append(key, new Blob([result.output]), key);
-            }
-            httpRequest.send({
-                data: formData,
-                bytesCount,
-            });
-        },
-    };
+	const reportError = (message) => {
+		lifeCycle.notify(15, { error: {
+			message,
+			type: _kubesense_kubesense_browser_core.DEFAULT_ERROR_TYPE,
+			source: _kubesense_kubesense_browser_core.ErrorSource.AGENT,
+			startClocks: (0, _kubesense_kubesense_js_core_time.clocksNow)()
+		} });
+		(0, _kubesense_kubesense_browser_core.addTelemetryDebug)("Error reported to customer", { "error.message": message });
+	};
+	const httpRequest = (0, _kubesense_kubesense_browser_core.createHttpRequest)([(0, _kubesense_kubesense_js_core_transport.createEndpointBuilder)(configuration, "profile")], reportError);
+	const encoder = createEncoder(streamId);
+	return { async send({ event, ...attachments }) {
+		const formData = new FormData();
+		const serializedEvent = (0, _kubesense_kubesense_browser_core.jsonStringify)(event);
+		if (!serializedEvent) throw new Error("Failed to serialize event");
+		formData.append("event", new Blob([serializedEvent], { type: "application/json" }), "event.json");
+		let bytesCount = serializedEvent.length;
+		for (const [key, value] of (0, _kubesense_kubesense_browser_core.objectEntries)(attachments)) {
+			const serializedValue = (0, _kubesense_kubesense_browser_core.jsonStringify)(value);
+			if (!serializedValue) throw new Error("Failed to serialize attachment");
+			const result = await encode(encoder, serializedValue);
+			bytesCount += result.outputBytesCount;
+			formData.append(key, new Blob([result.output]), key);
+		}
+		httpRequest.send({
+			data: formData,
+			bytesCount
+		});
+	} };
 }
 function encode(encoder, data) {
-    return new Promise((resolve) => {
-        encoder.write(data);
-        encoder.finish((encoderResult) => {
-            resolve(encoderResult);
-        });
-    });
+	return new Promise((resolve) => {
+		encoder.write(data);
+		encoder.finish((encoderResult) => {
+			resolve(encoderResult);
+		});
+	});
 }
+//#endregion
+exports.createFormDataTransport = createFormDataTransport;
+
 //# sourceMappingURL=formDataTransport.js.map

package/cjs/transport/formDataTransport.js.map

@@ -1 +1 @@
-{"version":3,"file":"formDataTransport.js","sourceRoot":"","sources":["../../src/transport/formDataTransport.ts"],"names":[],"mappings":";;AAyBA,0DAiDC;AAlED,8EAAsH;AAiBtH,SAAgB,uBAAuB,CACrC,aAA+B,EAC/B,SAAoB,EACpB,aAA4D,EAC5D,QAAgC;IAEhC,MAAM,WAAW,GAAG,CAAC,KAAe,EAAE,EAAE;QACtC,SAAS,CAAC,MAAM,kDAAyC,EAAE,KAAK,EAAE,CAAC,CAAA;QAEnE,6EAA6E;QAC7E,IAAA,0CAAiB,EAAC,4BAA4B,EAAE,EAAE,eAAe,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAA;IACrF,CAAC,CAAA;IAED,MAAM,WAAW,GAAG,IAAA,0CAAiB,EAAC,CAAC,aAAa,CAAC,wBAAwB,CAAC,EAAE,WAAW,CAAC,CAAA;IAE5F,MAAM,OAAO,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAA;IAEvC,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,WAAW,EAAK;YACrC,MAAM,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAA;YAC/B,MAAM,eAAe,GAAG,IAAA,sCAAa,EAAC,KAAK,CAAC,CAAA;YAE5C,IAAI,CAAC,eAAe,EAAE,CAAC;gBACrB,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAA;YAC9C,CAAC;YAED,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,CAAC,eAAe,CAAC,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,EAAE,YAAY,CAAC,CAAA;YAEjG,IAAI,UAAU,GAAG,eAAe,CAAC,MAAM,CAAA;YAEvC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAA,sCAAa,EAAC,WAAsC,CAAC,EAAE,CAAC;gBACjF,MAAM,eAAe,GAAG,IAAA,sCAAa,EAAC,KAAK,CAAC,CAAA;gBAE5C,IAAI,CAAC,eAAe,EAAE,CAAC;oBACrB,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAA;gBACnD,CAAC;gBAED,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;gBAErD,UAAU,IAAI,MAAM,CAAC,gBAAgB,CAAA;gBACrC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;YACtD,CAAC;YAED,WAAW,CAAC,IAAI,CAAC;gBACf,IAAI,EAAE,QAAQ;gBACd,UAAU;aACX,CAAC,CAAA;QACJ,CAAC;KACF,CAAA;AACH,CAAC;AAED,SAAS,MAAM,CAAsC,OAAmB,EAAE,IAAY;IACpF,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAEnB,OAAO,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,EAAE;YAC/B,OAAO,CAAC,aAAa,CAAC,CAAA;QACxB,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC"}
+{"version":3,"file":"formDataTransport.js","names":["DEFAULT_ERROR_TYPE","ErrorSource","clocksNow","createHttpRequest","createEndpointBuilder","jsonStringify","objectEntries"],"sources":["../../src/transport/formDataTransport.ts"],"sourcesContent":["import type {\n  Uint8ArrayBuffer,\n  Encoder,\n  EncoderResult,\n  DeflateEncoderStreamId,\n  Context,\n} from '@kubesense/kubesense-browser-core'\nimport {\n  addTelemetryDebug,\n  createHttpRequest,\n  jsonStringify,\n  objectEntries,\n  ErrorSource,\n  DEFAULT_ERROR_TYPE,\n} from '@kubesense/kubesense-browser-core'\nimport { clocksNow } from '@kubesense/kubesense-js-core/time'\nimport { createEndpointBuilder } from '@kubesense/kubesense-js-core/transport'\nimport type { RumConfiguration } from '../domain/configuration'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\n\n/**\n * transport payload consist of an event and one or more attachments\n */\nexport interface TransportPayload {\n  event: Context\n  [key: string]: Context\n}\n\nexport interface Transport<T extends TransportPayload> {\n  send: (data: T) => Promise<void>\n}\n\nexport function createFormDataTransport<T extends TransportPayload>(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  createEncoder: (streamId: DeflateEncoderStreamId) => Encoder,\n  streamId: DeflateEncoderStreamId\n) {\n  const reportError = (message: string) => {\n    lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, {\n      error: { message, type: DEFAULT_ERROR_TYPE, source: ErrorSource.AGENT, startClocks: clocksNow() },\n    })\n\n    // monitor-until: forever, to keep an eye on the errors reported to customers\n    addTelemetryDebug('Error reported to customer', { 'error.message': message })\n  }\n\n  const httpRequest = createHttpRequest([createEndpointBuilder(configuration, 'profile')], reportError)\n\n  const encoder = createEncoder(streamId)\n\n  return {\n    async send({ event, ...attachments }: T) {\n      const formData = new FormData()\n      const serializedEvent = jsonStringify(event)\n\n      if (!serializedEvent) {\n        throw new Error('Failed to serialize event')\n      }\n\n      formData.append('event', new Blob([serializedEvent], { type: 'application/json' }), 'event.json')\n\n      let bytesCount = serializedEvent.length\n\n      for (const [key, value] of objectEntries(attachments as Record<string, Context>)) {\n        const serializedValue = jsonStringify(value)\n\n        if (!serializedValue) {\n          throw new Error('Failed to serialize attachment')\n        }\n\n        const result = await encode(encoder, serializedValue)\n\n        bytesCount += result.outputBytesCount\n        formData.append(key, new Blob([result.output]), key)\n      }\n\n      httpRequest.send({\n        data: formData,\n        bytesCount,\n      })\n    },\n  }\n}\n\nfunction encode<T extends string | Uint8ArrayBuffer>(encoder: Encoder<T>, data: string): Promise<EncoderResult<T>> {\n  return new Promise((resolve) => {\n    encoder.write(data)\n\n    encoder.finish((encoderResult) => {\n      resolve(encoderResult)\n    })\n  })\n}\n"],"mappings":";;;;;AAiCA,SAAgB,wBACd,eACA,WACA,eACA,UACA;CACA,MAAM,eAAe,YAAoB;EACvC,UAAU,OAAA,IAA+C,EACvD,OAAO;GAAE;GAAS,MAAMA,kCAAAA;GAAoB,QAAQC,kCAAAA,YAAY;GAAO,cAAA,GAAaC,kCAAAA,UAAAA,CAAU;EAAE,EAClG,CAAC;EAGD,CAAA,GAAA,kCAAA,kBAAA,CAAkB,8BAA8B,EAAE,iBAAiB,QAAQ,CAAC;CAC9E;CAEA,MAAM,eAAA,GAAcC,kCAAAA,kBAAAA,CAAkB,EAAA,GAACC,uCAAAA,sBAAAA,CAAsB,eAAe,SAAS,CAAC,GAAG,WAAW;CAEpG,MAAM,UAAU,cAAc,QAAQ;CAEtC,OAAO,EACL,MAAM,KAAK,EAAE,OAAO,GAAG,eAAkB;EACvC,MAAM,WAAW,IAAI,SAAS;EAC9B,MAAM,mBAAA,GAAkBC,kCAAAA,cAAAA,CAAc,KAAK;EAE3C,IAAI,CAAC,iBACH,MAAM,IAAI,MAAM,2BAA2B;EAG7C,SAAS,OAAO,SAAS,IAAI,KAAK,CAAC,eAAe,GAAG,EAAE,MAAM,mBAAmB,CAAC,GAAG,YAAY;EAEhG,IAAI,aAAa,gBAAgB;EAEjC,KAAK,MAAM,CAAC,KAAK,WAAA,GAAUC,kCAAAA,cAAAA,CAAc,WAAsC,GAAG;GAChF,MAAM,mBAAA,GAAkBD,kCAAAA,cAAAA,CAAc,KAAK;GAE3C,IAAI,CAAC,iBACH,MAAM,IAAI,MAAM,gCAAgC;GAGlD,MAAM,SAAS,MAAM,OAAO,SAAS,eAAe;GAEpD,cAAc,OAAO;GACrB,SAAS,OAAO,KAAK,IAAI,KAAK,CAAC,OAAO,MAAM,CAAC,GAAG,GAAG;EACrD;EAEA,YAAY,KAAK;GACf,MAAM;GACN;EACF,CAAC;CACH,EACF;AACF;AAEA,SAAS,OAA4C,SAAqB,MAAyC;CACjH,OAAO,IAAI,SAAS,YAAY;EAC9B,QAAQ,MAAM,IAAI;EAElB,QAAQ,QAAQ,kBAAkB;GAChC,QAAQ,aAAa;EACvB,CAAC;CACH,CAAC;AACH"}

package/cjs/transport/startRumBatch.d.ts

@@ -1,5 +1,29 @@
-import type { Observable, RawError, PageMayExitEvent, Encoder } from '@kubesense/kubesense-browser-core';
-import { DeflateEncoderStreamId } from '@kubesense/kubesense-browser-core';
+import type { Observable, Encoder } from '@kubesense/kubesense-browser-core';
+import { createBatch, DeflateEncoderStreamId } from '@kubesense/kubesense-browser-core';
 import type { RumConfiguration } from '../domain/configuration';
 import type { LifeCycle } from '../domain/lifeCycle';
-export declare function startRumBatch(configuration: RumConfiguration, lifeCycle: LifeCycle, reportError: (error: RawError) => void, pageMayExitObservable: Observable<PageMayExitEvent>, sessionExpireObservable: Observable<void>, createEncoder: (streamId: DeflateEncoderStreamId) => Encoder): import("@kubesense/kubesense-browser-core/cjs/transport/batch").Batch;
+import type { AssembledRumEvent } from '../rawRumEvent.types';
+import type { RumViewEvent, RumViewUpdateEvent } from '../rumEvent.types';
+export declare 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 declare function computeAssembledViewDiff(current: RumViewEvent, last: RumViewEvent): AssembledViewDiff | undefined;
+/**
+ * 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 declare function createBatchDispatcher(batch: Pick<ReturnType<typeof createBatch>, 'flushObservable' | 'isEmpty' | 'add' | 'upsert'>, enableViewUpdates: boolean): {
+    dispatch: (event: AssembledRumEvent) => void;
+    stop: () => void;
+};
+export declare function startRumBatch(configuration: RumConfiguration, lifeCycle: LifeCycle, reportError: (message: string) => void, sessionExpireObservable: Observable<void>, createEncoder: (streamId: DeflateEncoderStreamId) => Encoder): import("@kubesense/kubesense-browser-core").Batch;

package/cjs/transport/startRumBatch.js

@@ -1,33 +1,134 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startRumBatch = startRumBatch;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const rawRumEvent_types_1 = require("../rawRumEvent.types");
-function startRumBatch(configuration, lifeCycle, reportError, pageMayExitObservable, sessionExpireObservable, createEncoder) {
-    const endpoints = [configuration.rumEndpointBuilder];
-    if (configuration.replica) {
-        endpoints.push(configuration.replica.rumEndpointBuilder);
-    }
-    const request = (0, kubesense_browser_core_1.createHttpRequest)(endpoints, reportError);
-    const batch = (0, kubesense_browser_core_1.createBatch)({
-        encoder: createEncoder(2 /* DeflateEncoderStreamId.RUM */),
-        request,
-        flushController: (0, kubesense_browser_core_1.createFlushController)({
-            pageMayExitObservable,
-            sessionExpireObservable,
-        }),
-    });
-    pageMayExitObservable.subscribe(() => {
-        request.sendQueuedOnExit();
-    });
-    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (serverRumEvent) => {
-        if (serverRumEvent.type === rawRumEvent_types_1.RumEventType.VIEW) {
-            batch.upsert(serverRumEvent, serverRumEvent.view.id);
-        }
-        else {
-            batch.add(serverRumEvent);
-        }
-    });
-    return batch;
+const require_rawRumEvent_types = require("../rawRumEvent.types.js");
+require("../domain/lifeCycle.js");
+const require_viewDiff = require("../domain/view/viewDiff.js");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_transport = require("@kubesense/kubesense-js-core/transport");
+function computeAssembledViewDiff(current, last) {
+	const diff = require_viewDiff.diffMerge(current, last, {
+		replaceKeys: /* @__PURE__ */ new Set([
+			"view.custom_timings",
+			"context",
+			"connectivity",
+			"usr",
+			"device",
+			"privacy"
+		]),
+		appendKeys: /* @__PURE__ */ new Set(["_kubesense.page_states"]),
+		ignoreKeys: /* @__PURE__ */ new Set([
+			"date",
+			"type",
+			"application",
+			"session",
+			"view.id",
+			"view.url",
+			"_kubesense.document_version",
+			"_kubesense.format_version"
+		])
+	});
+	if (!diff) return;
+	return (0, _kubesense_kubesense_js_core_util.combine)(diff, {
+		type: require_rawRumEvent_types.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.
+*/
+function createBatchDispatcher(batch, enableViewUpdates) {
+	let lastSentView;
+	let batchBase;
+	let batchHasFullView = false;
+	let viewUpdatesSinceCheckpoint = 0;
+	const { unsubscribe } = batch.flushObservable.subscribe(() => {
+		batchHasFullView = false;
+		batchBase = lastSentView;
+	});
+	return {
+		dispatch: (serverRumEvent) => {
+			if (serverRumEvent.type !== require_rawRumEvent_types.RumEventType.VIEW) {
+				batch.add(serverRumEvent);
+				return;
+			}
+			if (!enableViewUpdates) {
+				batch.upsert(serverRumEvent, serverRumEvent.view.id);
+				return;
+			}
+			const viewId = serverRumEvent.view.id;
+			if (!serverRumEvent.view.is_active) {
+				if (viewId === lastSentView?.view.id) {
+					lastSentView = void 0;
+					batchBase = void 0;
+					batchHasFullView = false;
+					viewUpdatesSinceCheckpoint = 0;
+				}
+				batch.upsert(serverRumEvent, viewId);
+				return;
+			}
+			if (viewId !== lastSentView?.view.id) {
+				viewUpdatesSinceCheckpoint = 0;
+				batch.upsert(serverRumEvent, viewId);
+				lastSentView = serverRumEvent;
+				batchHasFullView = !batch.isEmpty;
+				return;
+			}
+			lastSentView = serverRumEvent;
+			if (batchHasFullView) {
+				batch.upsert(serverRumEvent, viewId);
+				return;
+			}
+			viewUpdatesSinceCheckpoint += 1;
+			if (viewUpdatesSinceCheckpoint >= 100) {
+				viewUpdatesSinceCheckpoint = 0;
+				batch.upsert(serverRumEvent, viewId);
+				batchHasFullView = !batch.isEmpty;
+				return;
+			}
+			if (batchBase) {
+				const diff = computeAssembledViewDiff(serverRumEvent, batchBase);
+				if (diff) {
+					(0, _kubesense_kubesense_browser_core.sendToExtension)("rum", diff);
+					batch.upsert(diff, viewId);
+				}
+			}
+		},
+		stop: unsubscribe
+	};
 }
+function startRumBatch(configuration, lifeCycle, reportError, sessionExpireObservable, createEncoder) {
+	const endpoints = [(0, _kubesense_kubesense_js_core_transport.createEndpointBuilder)(configuration, "rum")];
+	const replicaEndpoint = (0, _kubesense_kubesense_js_core_transport.createReplicaEndpointBuilder)(configuration, "rum");
+	if (replicaEndpoint) endpoints.push(replicaEndpoint);
+	const batch = (0, _kubesense_kubesense_browser_core.createBatch)({
+		encoder: createEncoder(_kubesense_kubesense_browser_core.DeflateEncoderStreamId.RUM),
+		endpoints,
+		reportError
+	});
+	sessionExpireObservable.subscribe(() => batch.forceFlush("session_expire"));
+	const { dispatch, stop: stopDispatcher } = createBatchDispatcher(batch, configuration.betaEnableViewUpdates);
+	lifeCycle.subscribe(14, dispatch);
+	const stopBatch = batch.stop.bind(batch);
+	batch.stop = () => {
+		stopDispatcher();
+		stopBatch();
+	};
+	return batch;
+}
+//#endregion
+exports.computeAssembledViewDiff = computeAssembledViewDiff;
+exports.createBatchDispatcher = createBatchDispatcher;
+exports.startRumBatch = startRumBatch;
+
 //# sourceMappingURL=startRumBatch.js.map

package/cjs/transport/startRumBatch.js.map

@@ -1 +1 @@
-{"version":3,"file":"startRumBatch.js","sourceRoot":"","sources":["../../src/transport/startRumBatch.ts"],"names":[],"mappings":";;AAQA,sCAqCC;AA5CD,8EAAiI;AAKjI,4DAAmD;AAEnD,SAAgB,aAAa,CAC3B,aAA+B,EAC/B,SAAoB,EACpB,WAAsC,EACtC,qBAAmD,EACnD,uBAAyC,EACzC,aAA4D;IAE5D,MAAM,SAAS,GAAG,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAA;IACpD,IAAI,aAAa,CAAC,OAAO,EAAE,CAAC;QAC1B,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAA;IAC1D,CAAC;IAED,MAAM,OAAO,GAAG,IAAA,0CAAiB,EAAC,SAAS,EAAE,WAAW,CAAC,CAAA;IAEzD,MAAM,KAAK,GAAG,IAAA,oCAAW,EAAC;QACxB,OAAO,EAAE,aAAa,oCAA4B;QAClD,OAAO;QACP,eAAe,EAAE,IAAA,8CAAqB,EAAC;YACrC,qBAAqB;YACrB,uBAAuB;SACxB,CAAC;KACH,CAAC,CAAA;IAEF,qBAAqB,CAAC,SAAS,CAAC,GAAG,EAAE;QACnC,OAAO,CAAC,gBAAgB,EAAE,CAAA;IAC5B,CAAC,CAAC,CAAA;IAEF,SAAS,CAAC,SAAS,kDAAyC,CAAC,cAAiC,EAAE,EAAE;QAChG,IAAI,cAAc,CAAC,IAAI,KAAK,gCAAY,CAAC,IAAI,EAAE,CAAC;YAC9C,KAAK,CAAC,MAAM,CAAC,cAAc,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACtD,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;QAC3B,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO,KAAK,CAAA;AACd,CAAC"}
+{"version":3,"file":"startRumBatch.js","names":["diffMerge","combine","RumEventType","createEndpointBuilder","createReplicaEndpointBuilder","createBatch","DeflateEncoderStreamId"],"sources":["../../src/transport/startRumBatch.ts"],"sourcesContent":["import type { Observable, Encoder, Context } from '@kubesense/kubesense-browser-core'\nimport { createBatch, DeflateEncoderStreamId, sendToExtension } from '@kubesense/kubesense-browser-core'\nimport { combine } from '@kubesense/kubesense-js-core/util'\nimport { createEndpointBuilder, createReplicaEndpointBuilder } from '@kubesense/kubesense-js-core/transport'\nimport type { RumConfiguration } from '../domain/configuration'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\nimport type { AssembledRumEvent } from '../rawRumEvent.types'\nimport type { RumViewEvent, RumViewUpdateEvent } from '../rumEvent.types'\nimport { RumEventType } from '../rawRumEvent.types'\nimport { diffMerge } from '../domain/view/viewDiff'\n\nexport const PARTIAL_VIEW_UPDATE_CHECKPOINT_INTERVAL = 100\n\nexport type AssembledViewDiff = Omit<RumViewUpdateEvent, 'view' | '_kubesense'> & {\n  view: Partial<RumViewEvent['view']> & { id: string; url: string }\n  _kubesense?: { document_version: number; format_version: number; [k: string]: unknown }\n}\n\nexport function computeAssembledViewDiff(current: RumViewEvent, last: RumViewEvent): AssembledViewDiff | undefined {\n  const diff = diffMerge(current, last, {\n    // context, connectivity, usr, device, privacy are objects — use REPLACE to avoid partial updates\n    replaceKeys: new Set(['view.custom_timings', 'context', 'connectivity', 'usr', 'device', 'privacy']),\n    appendKeys: new Set(['_kubesense.page_states']),\n    // Ignore always-required fields — they are added back via combine regardless of changes\n    ignoreKeys: new Set([\n      'date',\n      'type',\n      'application',\n      'session',\n      'view.id',\n      'view.url',\n      '_kubesense.document_version',\n      '_kubesense.format_version',\n    ]),\n  })\n\n  if (!diff) {\n    return undefined\n  }\n\n  // Merge always-required fields on top of the diff for backend routing\n  return combine(diff, {\n    type: RumEventType.VIEW_UPDATE,\n    date: current.date,\n    application: current.application,\n    session: current.session,\n    view: {\n      id: current.view.id,\n      url: current.view.url,\n    },\n    _kubesense: {\n      document_version: current._kubesense.document_version,\n      format_version: current._kubesense.format_version,\n    },\n  })\n}\n\n/**\n * Dispatches assembled RUM events to the batch. VIEW events are handled specially:\n * intermediate updates either replace the full VIEW already in the batch, or are\n * aggregated into a single view_update diff against the last flushed state.\n */\nexport function createBatchDispatcher(\n  batch: Pick<ReturnType<typeof createBatch>, 'flushObservable' | 'isEmpty' | 'add' | 'upsert'>,\n  enableViewUpdates: boolean\n): { dispatch: (event: AssembledRumEvent) => void; stop: () => void } {\n  let lastSentView: RumViewEvent | undefined\n  // Base used to compute the aggregate diff for the current batch's view_update.\n  // Reset to lastSentView on each flush (= what the backend received in the previous batch).\n  let batchBase: RumViewEvent | undefined\n  // True when the current batch already contains a full VIEW event for the active view.\n  // Reset to false on each flush.\n  let batchHasFullView = false\n  let viewUpdatesSinceCheckpoint = 0\n\n  // On flush: advance batchBase to lastSentView (what the backend now has) and clear the flag.\n  // lastSentView is set AFTER batch.upsert() in the new-view and checkpoint paths so that if\n  // upsert() triggers a sync flush, the subscriber captures the previous view (what the backend\n  // actually received), not the one being added.\n  const { unsubscribe } = batch.flushObservable.subscribe(() => {\n    batchHasFullView = false\n    batchBase = lastSentView\n  })\n\n  return {\n    dispatch: (serverRumEvent: AssembledRumEvent) => {\n      if (serverRumEvent.type !== RumEventType.VIEW) {\n        // Non-view events: always append\n        batch.add(serverRumEvent)\n        return\n      }\n\n      if (!enableViewUpdates) {\n        // Feature OFF: existing behavior — upsert full view\n        batch.upsert(serverRumEvent, serverRumEvent.view.id)\n        return\n      }\n\n      const viewId = serverRumEvent.view.id\n\n      // View ended (is_active: false) — always send a full VIEW.\n      // Checked before the new-view guard so that a stale view-end for an old view\n      // (arriving after a new view has already started) is handled correctly: we upsert\n      // it without touching the state of the current view.\n      if (!serverRumEvent.view.is_active) {\n        if (viewId === lastSentView?.view.id) {\n          // Current view ended — reset all state\n          lastSentView = undefined\n          batchBase = undefined\n          batchHasFullView = false\n          viewUpdatesSinceCheckpoint = 0\n        }\n        batch.upsert(serverRumEvent, viewId)\n        return\n      }\n\n      // New view started\n      if (viewId !== lastSentView?.view.id) {\n        viewUpdatesSinceCheckpoint = 0\n        batch.upsert(serverRumEvent, viewId)\n        // lastSentView set AFTER upsert: if upsert triggers a sync flush, the subscriber\n        // captures the old lastSentView as batchBase (what the backend actually received),\n        // not the new view that hasn't been sent yet.\n        lastSentView = serverRumEvent\n        // If upsert triggered an after-add flush (e.g. messages_limit), the VIEW was sent\n        // and the batch is now empty — isEmpty is true. Otherwise the VIEW is in the batch.\n        batchHasFullView = !batch.isEmpty\n        return\n      }\n\n      // Intermediate update\n      lastSentView = serverRumEvent\n\n      if (batchHasFullView) {\n        // Optimization 1: batch already has a full VIEW — replace it with the latest full view.\n        // This is equivalent to the non-experimental upsert behavior for in-flight batches.\n        batch.upsert(serverRumEvent, viewId)\n        return\n      }\n\n      // Optimization 2: no full VIEW in the current batch — compute an aggregate diff from\n      // batchBase (last state the backend received) and upsert it under the same key as the VIEW.\n      // Each update replaces the previous aggregate, so the batch always contains at most one\n      // view_update per view ID.\n      //\n      // Note: view_update events are created here, post-assembly, bypassing\n      // RAW_RUM_EVENT_COLLECTED → assembly → RUM_EVENT_COLLECTED. They intentionally skip\n      // beforeSend — view_update is an internal bandwidth optimization, not a customer-visible type.\n\n      // Checkpoint: periodically send a full VIEW for backend reliability.\n      // When the checkpoint fires, upsert(VIEW) replaces any pending view_update (same key).\n      viewUpdatesSinceCheckpoint += 1\n      if (viewUpdatesSinceCheckpoint >= PARTIAL_VIEW_UPDATE_CHECKPOINT_INTERVAL) {\n        viewUpdatesSinceCheckpoint = 0\n        batch.upsert(serverRumEvent, viewId)\n        batchHasFullView = !batch.isEmpty\n        return\n      }\n\n      if (batchBase) {\n        const diff = computeAssembledViewDiff(serverRumEvent, batchBase)\n        if (diff) {\n          sendToExtension('rum', diff)\n          batch.upsert(diff as unknown as Context, viewId)\n        }\n      }\n    },\n    stop: unsubscribe,\n  }\n}\n\nexport function startRumBatch(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  reportError: (message: string) => void,\n  sessionExpireObservable: Observable<void>,\n  createEncoder: (streamId: DeflateEncoderStreamId) => Encoder\n) {\n  const endpoints = [createEndpointBuilder(configuration, 'rum')]\n  const replicaEndpoint = createReplicaEndpointBuilder(configuration, 'rum')\n  if (replicaEndpoint) {\n    endpoints.push(replicaEndpoint)\n  }\n\n  const batch = createBatch({\n    encoder: createEncoder(DeflateEncoderStreamId.RUM),\n    endpoints,\n    reportError,\n  })\n  sessionExpireObservable.subscribe(() => batch.forceFlush('session_expire'))\n\n  const { dispatch, stop: stopDispatcher } = createBatchDispatcher(batch, configuration.betaEnableViewUpdates)\n  lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, dispatch)\n\n  const stopBatch = batch.stop.bind(batch)\n  batch.stop = () => {\n    stopDispatcher()\n    stopBatch()\n  }\n\n  return batch\n}\n"],"mappings":"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"}

package/cjs/transport/startRumEventBridge.js

@@ -1,11 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startRumEventBridge = startRumEventBridge;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+require("../domain/lifeCycle.js");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/transport/startRumEventBridge.ts
 function startRumEventBridge(lifeCycle) {
-    const bridge = (0, kubesense_browser_core_1.getEventBridge)();
-    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (serverRumEvent) => {
-        bridge.send('rum', serverRumEvent);
-    });
+	const bridge = (0, _kubesense_kubesense_browser_core.getEventBridge)();
+	lifeCycle.subscribe(14, (serverRumEvent) => {
+		bridge.send("rum", serverRumEvent);
+	});
 }
+//#endregion
+exports.startRumEventBridge = startRumEventBridge;
+
 //# sourceMappingURL=startRumEventBridge.js.map

package/cjs/transport/startRumEventBridge.js.map

@@ -1 +1 @@
-{"version":3,"file":"startRumEventBridge.js","sourceRoot":"","sources":["../../src/transport/startRumEventBridge.ts"],"names":[],"mappings":";;AAKA,kDAMC;AAXD,8EAAkE;AAKlE,SAAgB,mBAAmB,CAAC,SAAoB;IACtD,MAAM,MAAM,GAAG,IAAA,uCAAc,GAAoB,CAAA;IAEjD,SAAS,CAAC,SAAS,kDAAyC,CAAC,cAAc,EAAE,EAAE;QAC7E,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,CAAA;IACpC,CAAC,CAAC,CAAA;AACJ,CAAC"}
+{"version":3,"file":"startRumEventBridge.js","names":["getEventBridge"],"sources":["../../src/transport/startRumEventBridge.ts"],"sourcesContent":["import { getEventBridge } from '@kubesense/kubesense-browser-core'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\nimport type { RumEvent } from '../rumEvent.types'\n\nexport function startRumEventBridge(lifeCycle: LifeCycle) {\n  const bridge = getEventBridge<'rum', RumEvent>()!\n\n  lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (serverRumEvent) => {\n    bridge.send('rum', serverRumEvent)\n  })\n}\n"],"mappings":";;;AAKA,SAAgB,oBAAoB,WAAsB;CACxD,MAAM,UAAA,GAASA,kCAAAA,eAAAA,CAAgC;CAE/C,UAAU,UAAA,KAAmD,mBAAmB;EAC9E,OAAO,KAAK,OAAO,cAAc;CACnC,CAAC;AACH"}

package/esm/boot/preStartRum.mjs

@@ -0,0 +1,233 @@
+import { fetchAndApplyRemoteConfiguration, getRemoteConfiguration, getRemoteConfigurationId } from "../domain/configuration/remoteConfiguration.mjs";
+import { serializeRumConfiguration, validateAndBuildRumConfiguration } from "../domain/configuration/configuration.mjs";
+import { applyCachedSdkConfiguration, scheduleSdkConfigurationRefresh } from "../domain/configuration/remoteSdkConfiguration.mjs";
+import "../domain/configuration/index.mjs";
+import { callPluginsOnInit } from "../domain/plugins.mjs";
+import { createHooks } from "../domain/hooks.mjs";
+import { startTrackingConsentContext } from "../domain/contexts/trackingConsentContext.mjs";
+import { clocksNow, timeStampNow } from "@kubesense/kubesense-js-core/time";
+import { isWorkerEnvironment } from "@kubesense/kubesense-js-core/util";
+import { BufferedObservable, CustomerContextKey, TelemetryService, addTelemetryConfiguration, addTelemetryDebug, bufferContextCalls, buildAccountContextManager, buildGlobalContextManager, buildUserContextManager, canUseEventBridge, display, displayAlreadyInitializedError, getEventBridge, initFeatureFlags, isAllowedTrackingOrigins, mockable, noop, sanitize, setAllowUntrustedEvents, startSessionManager, startSessionManagerStub, startTelemetry, startTelemetrySessionContext, willSyntheticsInjectRum } from "@kubesense/kubesense-browser-core";
+import { monitorError } from "@kubesense/kubesense-js-core/monitor";
+//#region src/boot/preStartRum.ts
+function createPreStartStrategy({ ignoreInitIfSyntheticsWillInjectRum = true, startDeflateWorker, sdkName }, trackingConsentState, doStartRum) {
+	const bufferApiCalls = new BufferedObservable(500, (count) => {
+		addTelemetryDebug("preStartRum buffer data lost", { count });
+	});
+	const globalContext = buildGlobalContextManager();
+	bufferContextCalls(globalContext, CustomerContextKey.globalContext, bufferApiCalls);
+	const userContext = buildUserContextManager();
+	bufferContextCalls(userContext, CustomerContextKey.userContext, bufferApiCalls);
+	const accountContext = buildAccountContextManager();
+	bufferContextCalls(accountContext, CustomerContextKey.accountContext, bufferApiCalls);
+	let firstStartViewCall;
+	let deflateWorker;
+	let cachedInitConfiguration;
+	let cachedConfiguration;
+	let sessionManager;
+	let telemetry;
+	const hooks = createHooks();
+	const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartRum);
+	const emptyContext = {};
+	let started = false;
+	function tryStartRum() {
+		if (started || !cachedInitConfiguration || !cachedConfiguration || !sessionManager || !telemetry) return;
+		trackingConsentStateSubscription.unsubscribe();
+		let initialViewOptions;
+		if (cachedConfiguration.trackViewsManually) {
+			if (!firstStartViewCall) return;
+			initialViewOptions = firstStartViewCall.options;
+		}
+		const callbackToSkip = cachedConfiguration.trackViewsManually ? firstStartViewCall?.callback : void 0;
+		const startRumResult = doStartRum(cachedConfiguration, sessionManager, deflateWorker, initialViewOptions, telemetry, hooks);
+		started = true;
+		bufferApiCalls.subscribe((callback) => {
+			if (callback !== callbackToSkip) callback(startRumResult);
+		});
+		bufferApiCalls.unbuffer();
+	}
+	function doInit(initConfiguration, errorStack, remoteConfigurationMetadata) {
+		const eventBridgeAvailable = canUseEventBridge();
+		if (eventBridgeAvailable) initConfiguration = overrideInitConfigurationForBridge(initConfiguration);
+		const remoteSdkConfigurationEnabled = !!initConfiguration.enableRemoteSdkConfiguration;
+		const refreshRemoteSdkConfiguration = () => {
+			if (remoteSdkConfigurationEnabled) scheduleSdkConfigurationRefresh(initConfiguration).catch(monitorError);
+		};
+		if (remoteSdkConfigurationEnabled) {
+			const cachedSdkConfiguration = applyCachedSdkConfiguration(initConfiguration, {
+				globalContext,
+				userContext
+			});
+			initConfiguration = cachedSdkConfiguration.initConfiguration;
+			if (!cachedSdkConfiguration.rumEnabled) {
+				cachedInitConfiguration = initConfiguration;
+				refreshRemoteSdkConfiguration();
+				return;
+			}
+		}
+		cachedInitConfiguration = initConfiguration;
+		if (cachedConfiguration) {
+			displayAlreadyInitializedError("KUBESENSE_SDK", initConfiguration);
+			return;
+		}
+		const configuration = validateAndBuildRumConfiguration(initConfiguration, sdkName);
+		if (!configuration || !isAllowedTrackingOrigins(configuration, errorStack ?? "")) {
+			refreshRemoteSdkConfiguration();
+			return;
+		}
+		if (configuration.compressIntakeRequests && !eventBridgeAvailable && startDeflateWorker) {
+			deflateWorker = startDeflateWorker(configuration, "KubeSense RUM", noop);
+			if (!deflateWorker) {
+				refreshRemoteSdkConfiguration();
+				return;
+			}
+		}
+		cachedConfiguration = configuration;
+		trackingConsentState.tryToInit(configuration.trackingConsent);
+		trackingConsentState.onGrantedOnce(() => {
+			const { assembleTelemetry: assembleTelemetryHook } = hooks;
+			startTrackingConsentContext(assembleTelemetryHook, trackingConsentState);
+			telemetry = mockable(startTelemetry)(TelemetryService.RUM, configuration, assembleTelemetryHook, sdkName);
+			if (isWorkerEnvironment) {
+				display.warn("The RUM SDK is not supported in a web or service worker environment.");
+				return;
+			}
+			(canUseEventBridge() ? startSessionManagerStub() : mockable(startSessionManager)(configuration, trackingConsentState)).then((newSessionManager) => {
+				if (!newSessionManager) return;
+				sessionManager = newSessionManager;
+				startTelemetrySessionContext(assembleTelemetryHook, sessionManager, { application: { id: configuration.applicationId } });
+				addTelemetryConfiguration(serializeRumConfiguration(initConfiguration, sdkName, remoteConfigurationMetadata));
+				tryStartRum();
+				refreshRemoteSdkConfiguration();
+			}).catch(monitorError);
+		});
+	}
+	const addOperationStepVital = (name, stepType, options, failureReason) => {
+		bufferApiCalls.notify((startRumResult) => startRumResult.addOperationStepVital(sanitize(name), stepType, sanitize(options), sanitize(failureReason)));
+	};
+	return {
+		init(initConfiguration, publicApi, errorStack) {
+			if (!initConfiguration) {
+				display.error("Missing configuration");
+				return;
+			}
+			initFeatureFlags(initConfiguration.enableExperimentalFeatures);
+			setAllowUntrustedEvents(initConfiguration.allowUntrustedEvents);
+			cachedInitConfiguration = initConfiguration;
+			if (ignoreInitIfSyntheticsWillInjectRum && willSyntheticsInjectRum()) return;
+			const shouldContinue = callPluginsOnInit(initConfiguration.plugins, {
+				initConfiguration,
+				publicApi,
+				registerAssembleEventHook: hooks.assembleEvent.register
+			});
+			if (typeof shouldContinue === "boolean") {
+				if (shouldContinue) proceedWithInit();
+			} else shouldContinue.then((result) => {
+				if (result) proceedWithInit();
+			}).catch(monitorError);
+			function proceedWithInit() {
+				if (getRemoteConfigurationId(initConfiguration)) {
+					const supportedContextManagers = {
+						user: userContext,
+						context: globalContext
+					};
+					if (!!initConfiguration.remoteConfigurationId || !!initConfiguration.remoteConfiguration?.sync) fetchAndApplyRemoteConfiguration(initConfiguration, supportedContextManagers).then((resolvedInitConfiguration) => {
+						if (resolvedInitConfiguration) doInit(resolvedInitConfiguration, errorStack);
+					}).catch(monitorError);
+					else {
+						const resolvedRemoteConfiguration = getRemoteConfiguration(initConfiguration, supportedContextManagers);
+						if (resolvedRemoteConfiguration) doInit(resolvedRemoteConfiguration.initConfiguration, errorStack, resolvedRemoteConfiguration.metadata);
+					}
+				} else doInit(initConfiguration, errorStack);
+			}
+		},
+		get initConfiguration() {
+			return cachedInitConfiguration;
+		},
+		getInternalContext: noop,
+		stopSession: noop,
+		addTiming(name, time = timeStampNow()) {
+			bufferApiCalls.notify((startRumResult) => startRumResult.addTiming(name, time));
+		},
+		setLoadingTime: ((callTimestamp) => {
+			bufferApiCalls.notify((startRumResult) => startRumResult.setLoadingTime(callTimestamp));
+		}),
+		startView(options, startClocks = clocksNow()) {
+			const callback = (startRumResult) => {
+				startRumResult.startView(options, startClocks);
+			};
+			bufferApiCalls.notify(callback);
+			if (!firstStartViewCall) {
+				firstStartViewCall = {
+					options,
+					callback
+				};
+				tryStartRum();
+			}
+		},
+		setViewName(name) {
+			bufferApiCalls.notify((startRumResult) => startRumResult.setViewName(name));
+		},
+		setViewContext(context) {
+			bufferApiCalls.notify((startRumResult) => startRumResult.setViewContext(context));
+		},
+		setViewContextProperty(key, value) {
+			bufferApiCalls.notify((startRumResult) => startRumResult.setViewContextProperty(key, value));
+		},
+		getViewContext: () => emptyContext,
+		globalContext,
+		userContext,
+		accountContext,
+		addAction(action) {
+			bufferApiCalls.notify((startRumResult) => startRumResult.addAction(action));
+		},
+		startAction(name, options) {
+			const startClocks = clocksNow();
+			bufferApiCalls.notify((startRumResult) => startRumResult.startAction(name, options, startClocks));
+		},
+		stopAction(name, options) {
+			const stopClocks = clocksNow();
+			bufferApiCalls.notify((startRumResult) => startRumResult.stopAction(name, options, stopClocks));
+		},
+		startResource(url, options) {
+			const startClocks = clocksNow();
+			bufferApiCalls.notify((startRumResult) => startRumResult.startResource(url, options, startClocks));
+		},
+		stopResource(url, options) {
+			const stopClocks = clocksNow();
+			bufferApiCalls.notify((startRumResult) => startRumResult.stopResource(url, options, stopClocks));
+		},
+		addError(providedError) {
+			bufferApiCalls.notify((startRumResult) => startRumResult.addError(providedError));
+		},
+		addFeatureFlagEvaluation(key, value) {
+			bufferApiCalls.notify((startRumResult) => startRumResult.addFeatureFlagEvaluation(key, value));
+		},
+		startDurationVital(name, options) {
+			const startClocks = clocksNow();
+			bufferApiCalls.notify((startRumResult) => startRumResult.startDurationVital(name, options, startClocks));
+		},
+		stopDurationVital(name, options) {
+			const stopClocks = clocksNow();
+			bufferApiCalls.notify((startRumResult) => startRumResult.stopDurationVital(name, options, stopClocks));
+		},
+		addDurationVital(vital) {
+			bufferApiCalls.notify((startRumResult) => startRumResult.addDurationVital(vital));
+		},
+		addOperationStepVital
+	};
+}
+function overrideInitConfigurationForBridge(initConfiguration) {
+	return {
+		...initConfiguration,
+		service: initConfiguration.service || initConfiguration.applicationId,
+		applicationId: "00000000-aaaa-0000-aaaa-000000000000",
+		clientToken: "empty",
+		sessionSampleRate: 100,
+		defaultPrivacyLevel: initConfiguration.defaultPrivacyLevel ?? getEventBridge()?.getPrivacyLevel()
+	};
+}
+//#endregion
+export { createPreStartStrategy };
+
+//# sourceMappingURL=preStartRum.mjs.map