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

package/esm/boot/kubesenseRecorder.mjs

@@ -0,0 +1,75 @@
+import { record } from "../domain/record/record.mjs";
+import "../domain/record/index.mjs";
+import { SEGMENT_BYTES_LIMIT, startSegmentCollection } from "../domain/segmentCollection/segmentCollection.mjs";
+import { startSegmentTelemetry } from "../domain/segmentCollection/startSegmentTelemetry.mjs";
+import { startDroppedSegmentRecovery } from "../domain/segmentCollection/startDroppedSegmentRecovery.mjs";
+import { startReplayResourceCollection } from "../domain/segmentCollection/replayResourceCollection.mjs";
+import "../domain/segmentCollection/index.mjs";
+import { startRecordBridge } from "../domain/startRecordBridge.mjs";
+import { LifeCycleEventType } from "@kubesense/kubesense-browser-rum-core";
+import { DEFAULT_ERROR_TYPE, ErrorSource, addTelemetryDebug, canUseEventBridge, createHttpRequest, noop } from "@kubesense/kubesense-browser-core";
+import { clocksNow } from "@kubesense/kubesense-js-core/time";
+import { createEndpointBuilder } from "@kubesense/kubesense-js-core/transport";
+//#region src/boot/kubesenseRecorder.ts
+/**
+* Retries for a replay upload — segment or canvas frame — that failed with a network error. Unlike a
+* lost RUM batch, a lost segment breaks the rest of its view's replay, which builds on the DOM it
+* carried, and a lost frame leaves its canvas blank until the next one.
+*/
+const REPLAY_NETWORK_ERROR_RETRIES = 3;
+function startRecording(lifeCycle, configuration, sessionManager, viewHistory, encoder, telemetry, segmentHttpRequest, resourceHttpRequest) {
+	const cleanupTasks = [];
+	const reportError = (message) => {
+		lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, { error: {
+			message,
+			type: DEFAULT_ERROR_TYPE,
+			source: ErrorSource.AGENT,
+			startClocks: clocksNow()
+		} });
+		addTelemetryDebug("Error reported to customer", { "error.message": message });
+	};
+	const replayRequest = segmentHttpRequest || createHttpRequest([createEndpointBuilder(configuration, "replay")], reportError, SEGMENT_BYTES_LIMIT, REPLAY_NETWORK_ERROR_RETRIES);
+	const resourceRequest = resourceHttpRequest || createHttpRequest([createEndpointBuilder(configuration, "replay")], reportError, 0, REPLAY_NETWORK_ERROR_RETRIES);
+	let addRecord;
+	let addStats;
+	let emitResource = noop;
+	let flushMutations = noop;
+	const { unsubscribe: unsubscribeMutationFlush } = lifeCycle.subscribe(LifeCycleEventType.PREPARE_URGENT_FLUSH, () => flushMutations());
+	cleanupTasks.push(unsubscribeMutationFlush);
+	if (!canUseEventBridge()) {
+		const segmentCollection = startSegmentCollection(lifeCycle, configuration, sessionManager, viewHistory, replayRequest, encoder);
+		addRecord = segmentCollection.addRecord;
+		addStats = segmentCollection.addStats;
+		cleanupTasks.push(segmentCollection.stop);
+		const segmentTelemetry = startSegmentTelemetry(telemetry, replayRequest.observable);
+		cleanupTasks.push(segmentTelemetry.stop);
+		const replayResourceCollection = startReplayResourceCollection(configuration.applicationId, lifeCycle, resourceRequest);
+		emitResource = replayResourceCollection.emitResource;
+		cleanupTasks.push(replayResourceCollection.stop);
+	} else {
+		({addRecord} = startRecordBridge(viewHistory));
+		addStats = noop;
+	}
+	const recording = record({
+		emitRecord: addRecord,
+		emitResource,
+		emitStats: addStats,
+		configuration,
+		lifeCycle,
+		viewHistory
+	});
+	flushMutations = recording.flushMutations;
+	if (!canUseEventBridge()) {
+		const recovery = startDroppedSegmentRecovery(replayRequest.observable, recording.takeFullSnapshot);
+		cleanupTasks.push(recovery.stop);
+	}
+	return { stop: () => {
+		recording.flushMutations();
+		recording.stop();
+		cleanupTasks.forEach((task) => task());
+	} };
+}
+//#endregion
+export { startRecording };
+
+//# sourceMappingURL=kubesenseRecorder.mjs.map

package/esm/boot/kubesenseRecorder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kubesenseRecorder.mjs","names":[],"sources":["../../src/boot/kubesenseRecorder.ts"],"sourcesContent":["import type { HttpRequest, DeflateEncoder, Telemetry, SessionManager } from '@kubesense/kubesense-browser-core'\nimport {\n  createHttpRequest,\n  addTelemetryDebug,\n  canUseEventBridge,\n  noop,\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 { LifeCycle, ViewHistory, RumConfiguration } from '@kubesense/kubesense-browser-rum-core'\nimport { LifeCycleEventType } from '@kubesense/kubesense-browser-rum-core'\n\nimport type { EmitResourceCallback, SerializationStats } from '../domain/record'\nimport { record } from '../domain/record'\nimport type { ReplayPayload, ResourcePayload } from '../domain/segmentCollection'\nimport {\n  startDroppedSegmentRecovery,\n  startSegmentCollection,\n  SEGMENT_BYTES_LIMIT,\n  startSegmentTelemetry,\n  startReplayResourceCollection,\n} from '../domain/segmentCollection'\nimport type { BrowserRecord } from '../types'\nimport { startRecordBridge } from '../domain/startRecordBridge'\n\n/**\n * Retries for a replay upload — segment or canvas frame — that failed with a network error. Unlike a\n * lost RUM batch, a lost segment breaks the rest of its view's replay, which builds on the DOM it\n * carried, and a lost frame leaves its canvas blank until the next one.\n */\nconst REPLAY_NETWORK_ERROR_RETRIES = 3\n\nexport function startRecording(\n  lifeCycle: LifeCycle,\n  configuration: RumConfiguration,\n  sessionManager: SessionManager,\n  viewHistory: ViewHistory,\n  encoder: DeflateEncoder,\n  telemetry: Telemetry,\n  segmentHttpRequest?: HttpRequest<ReplayPayload>,\n  resourceHttpRequest?: HttpRequest<ResourcePayload>\n) {\n  const cleanupTasks: Array<() => void> = []\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    // 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 replayRequest =\n    segmentHttpRequest ||\n    createHttpRequest(\n      [createEndpointBuilder(configuration, 'replay')],\n      reportError,\n      SEGMENT_BYTES_LIMIT,\n      REPLAY_NETWORK_ERROR_RETRIES\n    )\n\n  const resourceRequest =\n    resourceHttpRequest ||\n    createHttpRequest<ResourcePayload>(\n      [createEndpointBuilder(configuration, 'replay')],\n      reportError,\n      0,\n      REPLAY_NETWORK_ERROR_RETRIES\n    )\n\n  let addRecord: (record: BrowserRecord) => void\n  let addStats: (stats: SerializationStats) => void\n  let emitResource: EmitResourceCallback = noop\n  let flushMutations = noop\n\n  // This must be registered before the segment and resource collectors so an urgent exit includes queued canvas changes.\n  const { unsubscribe: unsubscribeMutationFlush } = lifeCycle.subscribe(LifeCycleEventType.PREPARE_URGENT_FLUSH, () =>\n    flushMutations()\n  )\n  cleanupTasks.push(unsubscribeMutationFlush)\n\n  if (!canUseEventBridge()) {\n    const segmentCollection = startSegmentCollection(\n      lifeCycle,\n      configuration,\n      sessionManager,\n      viewHistory,\n      replayRequest,\n      encoder\n    )\n    addRecord = segmentCollection.addRecord\n    addStats = segmentCollection.addStats\n    cleanupTasks.push(segmentCollection.stop)\n\n    const segmentTelemetry = startSegmentTelemetry(telemetry, replayRequest.observable)\n    cleanupTasks.push(segmentTelemetry.stop)\n\n    const replayResourceCollection = startReplayResourceCollection(\n      configuration.applicationId,\n      lifeCycle,\n      resourceRequest\n    )\n    emitResource = replayResourceCollection.emitResource\n    cleanupTasks.push(replayResourceCollection.stop)\n  } else {\n    ;({ addRecord } = startRecordBridge(viewHistory))\n    addStats = noop\n  }\n\n  const recording = record({\n    emitRecord: addRecord,\n    emitResource,\n    emitStats: addStats,\n    configuration,\n    lifeCycle,\n    viewHistory,\n  })\n  flushMutations = recording.flushMutations\n\n  if (!canUseEventBridge()) {\n    const recovery = startDroppedSegmentRecovery(replayRequest.observable, recording.takeFullSnapshot)\n    cleanupTasks.push(recovery.stop)\n  }\n\n  return {\n    stop: () => {\n      recording.flushMutations()\n      recording.stop()\n      cleanupTasks.forEach((task) => task())\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgCA,MAAM,+BAA+B;AAErC,SAAgB,eACd,WACA,eACA,gBACA,aACA,SACA,WACA,oBACA,qBACA;CACA,MAAM,eAAkC,CAAC;CAEzC,MAAM,eAAe,YAAoB;EACvC,UAAU,OAAO,mBAAmB,qBAAqB,EACvD,OAAO;GAAE;GAAS,MAAM;GAAoB,QAAQ,YAAY;GAAO,aAAa,UAAU;EAAE,EAClG,CAAC;EAED,kBAAkB,8BAA8B,EAAE,iBAAiB,QAAQ,CAAC;CAC9E;CAEA,MAAM,gBACJ,sBACA,kBACE,CAAC,sBAAsB,eAAe,QAAQ,CAAC,GAC/C,aACA,qBACA,4BACF;CAEF,MAAM,kBACJ,uBACA,kBACE,CAAC,sBAAsB,eAAe,QAAQ,CAAC,GAC/C,aACA,GACA,4BACF;CAEF,IAAI;CACJ,IAAI;CACJ,IAAI,eAAqC;CACzC,IAAI,iBAAiB;CAGrB,MAAM,EAAE,aAAa,6BAA6B,UAAU,UAAU,mBAAmB,4BACvF,eAAe,CACjB;CACA,aAAa,KAAK,wBAAwB;CAE1C,IAAI,CAAC,kBAAkB,GAAG;EACxB,MAAM,oBAAoB,uBACxB,WACA,eACA,gBACA,aACA,eACA,OACF;EACA,YAAY,kBAAkB;EAC9B,WAAW,kBAAkB;EAC7B,aAAa,KAAK,kBAAkB,IAAI;EAExC,MAAM,mBAAmB,sBAAsB,WAAW,cAAc,UAAU;EAClF,aAAa,KAAK,iBAAiB,IAAI;EAEvC,MAAM,2BAA2B,8BAC/B,cAAc,eACd,WACA,eACF;EACA,eAAe,yBAAyB;EACxC,aAAa,KAAK,yBAAyB,IAAI;CACjD,OAAO;EACJ,CAAC,CAAE,aAAc,kBAAkB,WAAW;EAC/C,WAAW;CACb;CAEA,MAAM,YAAY,OAAO;EACvB,YAAY;EACZ;EACA,WAAW;EACX;EACA;EACA;CACF,CAAC;CACD,iBAAiB,UAAU;CAE3B,IAAI,CAAC,kBAAkB,GAAG;EACxB,MAAM,WAAW,4BAA4B,cAAc,YAAY,UAAU,gBAAgB;EACjG,aAAa,KAAK,SAAS,IAAI;CACjC;CAEA,OAAO,EACL,YAAY;EACV,UAAU,eAAe;EACzB,UAAU,KAAK;EACf,aAAa,SAAS,SAAS,KAAK,CAAC;CACvC,EACF;AACF"}

package/esm/boot/lazyLoadProfiler.mjs

@@ -0,0 +1,24 @@
+import { reportScriptLoadingError } from "../domain/scriptLoadingError.mjs";
+import { mockable } from "@kubesense/kubesense-browser-core";
+//#region src/boot/lazyLoadProfiler.ts
+async function lazyLoadProfiler() {
+	try {
+		return await mockable(importProfiler)();
+	} catch (error) {
+		reportScriptLoadingError({
+			error,
+			source: "Profiler",
+			scriptType: "module"
+		});
+	}
+}
+async function importProfiler() {
+	return (await import(
+		/* webpackChunkName: "kubesenseProfiler" */
+		"../domain/profiling/kubesenseProfiler.mjs"
+)).createRumProfiler;
+}
+//#endregion
+export { importProfiler, lazyLoadProfiler };
+
+//# sourceMappingURL=lazyLoadProfiler.mjs.map

package/esm/boot/lazyLoadProfiler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyLoadProfiler.mjs","names":[],"sources":["../../src/boot/lazyLoadProfiler.ts"],"sourcesContent":["import { mockable } from '@kubesense/kubesense-browser-core'\nimport { reportScriptLoadingError } from '../domain/scriptLoadingError'\nimport type { createRumProfiler } from '../domain/profiling/kubesenseProfiler'\n\nexport async function lazyLoadProfiler(): Promise<typeof createRumProfiler | undefined> {\n  try {\n    return await mockable(importProfiler)()\n  } catch (error: unknown) {\n    reportScriptLoadingError({\n      error,\n      source: 'Profiler',\n      scriptType: 'module',\n    })\n  }\n}\n\nexport async function importProfiler() {\n  const module = await import(/* webpackChunkName: \"kubesenseProfiler\" */ '../domain/profiling/kubesenseProfiler')\n  return module.createRumProfiler\n}\n"],"mappings":";;;AAIA,eAAsB,mBAAkE;CACtF,IAAI;EACF,OAAO,MAAM,SAAS,cAAc,CAAC,CAAC;CACxC,SAAS,OAAgB;EACvB,yBAAyB;GACvB;GACA,QAAQ;GACR,YAAY;EACd,CAAC;CACH;AACF;AAEA,eAAsB,iBAAiB;CAErC,QAAO,MADc;;EAAmD;EAC3D,CAAC;AAChB"}

package/esm/boot/lazyLoadRecorder.mjs

@@ -0,0 +1,24 @@
+import { reportScriptLoadingError } from "../domain/scriptLoadingError.mjs";
+import { mockable } from "@kubesense/kubesense-browser-core";
+//#region src/boot/lazyLoadRecorder.ts
+async function lazyLoadRecorder() {
+	try {
+		return await mockable(importRecorder)();
+	} catch (error) {
+		reportScriptLoadingError({
+			error,
+			source: "Recorder",
+			scriptType: "module"
+		});
+	}
+}
+async function importRecorder() {
+	return (await import(
+		/* webpackChunkName: "kubesenseRecorder" */
+		"./kubesenseRecorder.mjs"
+)).startRecording;
+}
+//#endregion
+export { importRecorder, lazyLoadRecorder };
+
+//# sourceMappingURL=lazyLoadRecorder.mjs.map

package/esm/boot/lazyLoadRecorder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyLoadRecorder.mjs","names":[],"sources":["../../src/boot/lazyLoadRecorder.ts"],"sourcesContent":["import { mockable } from '@kubesense/kubesense-browser-core'\nimport { reportScriptLoadingError } from '../domain/scriptLoadingError'\nimport type { startRecording } from './kubesenseRecorder'\n\nexport async function lazyLoadRecorder(): Promise<typeof startRecording | undefined> {\n  try {\n    return await mockable(importRecorder)()\n  } catch (error: unknown) {\n    reportScriptLoadingError({\n      error,\n      source: 'Recorder',\n      scriptType: 'module',\n    })\n  }\n}\n\nexport async function importRecorder() {\n  const module = await import(/* webpackChunkName: \"kubesenseRecorder\" */ './kubesenseRecorder')\n  return module.startRecording\n}\n"],"mappings":";;;AAIA,eAAsB,mBAA+D;CACnF,IAAI;EACF,OAAO,MAAM,SAAS,cAAc,CAAC,CAAC;CACxC,SAAS,OAAgB;EACvB,yBAAyB;GACvB;GACA,QAAQ;GACR,YAAY;EACd,CAAC;CACH;AACF;AAEA,eAAsB,iBAAiB;CAErC,QAAO,MADc;;EAAmD;EAC3D,CAAC;AAChB"}

package/esm/boot/postStartStrategy.mjs

@@ -0,0 +1,97 @@
+import { getSessionReplayLink } from "../domain/getSessionReplayLink.mjs";
+import { startRecorderInitTelemetry } from "../domain/startRecorderInitTelemetry.mjs";
+import { lazyLoadRecorder } from "./lazyLoadRecorder.mjs";
+import { LifeCycleEventType, SessionReplayState, computeSessionReplayState, getRoutePath, isRouteRecordable } from "@kubesense/kubesense-browser-rum-core";
+import { Observable, asyncRunOnReadyState } from "@kubesense/kubesense-browser-core";
+import { monitorError } from "@kubesense/kubesense-js-core/monitor";
+//#region src/boot/postStartStrategy.ts
+function createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, getOrCreateDeflateEncoder, telemetry) {
+	let status = 0;
+	let stopRecording;
+	lifeCycle.subscribe(LifeCycleEventType.SESSION_EXPIRED, () => {
+		if (status === 2 || status === 3) {
+			stop();
+			status = 1;
+		}
+	});
+	lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {
+		if (status === 1) start();
+	});
+	if (configuration.sessionReplayRoutes) lifeCycle.subscribe(LifeCycleEventType.VIEW_CREATED, () => {
+		if (isRouteRecordable(configuration.sessionReplayRoutes, getRoutePath())) start();
+		else stop();
+	});
+	const observable = new Observable();
+	startRecorderInitTelemetry(telemetry, observable);
+	const doStart = async (forced) => {
+		observable.notify({
+			type: "start",
+			forced
+		});
+		const [startRecordingImpl] = await Promise.all([notifyWhenSettled(observable, { type: "recorder-settled" }, lazyLoadRecorder()), notifyWhenSettled(observable, { type: "document-ready" }, asyncRunOnReadyState("interactive"))]);
+		if (status !== 2) {
+			observable.notify({ type: "aborted" });
+			return;
+		}
+		if (!startRecordingImpl) {
+			status = 0;
+			observable.notify({ type: "recorder-load-failed" });
+			return;
+		}
+		const deflateEncoder = getOrCreateDeflateEncoder();
+		if (!deflateEncoder) {
+			status = 0;
+			observable.notify({ type: "deflate-encoder-load-failed" });
+			return;
+		}
+		({stop: stopRecording} = startRecordingImpl(lifeCycle, configuration, sessionManager, viewHistory, deflateEncoder, telemetry));
+		status = 3;
+		observable.notify({ type: "succeeded" });
+	};
+	function start(options) {
+		if (!options?.force && !isRouteRecordable(configuration.sessionReplayRoutes, getRoutePath())) return;
+		const session = sessionManager.findTrackedSession();
+		const replayState = session ? computeSessionReplayState(session, configuration) : void 0;
+		if (!canStartRecording(replayState, options)) {
+			status = 1;
+			return;
+		}
+		if (isRecordingInProgress(status)) return;
+		status = 2;
+		const forced = shouldForceReplay(replayState, options) || false;
+		doStart(forced).catch(monitorError);
+		if (forced) sessionManager.updateSessionState({ forcedReplay: "1" });
+	}
+	function stop() {
+		if (status === 3) stopRecording?.();
+		status = 0;
+	}
+	return {
+		start,
+		stop,
+		getSessionReplayLink() {
+			return getSessionReplayLink(configuration, sessionManager, viewHistory, status !== 0);
+		},
+		isRecording: () => status === 3
+	};
+}
+function canStartRecording(replayState, options) {
+	return replayState !== void 0 && (replayState !== SessionReplayState.OFF || options?.force);
+}
+function isRecordingInProgress(status) {
+	return status === 2 || status === 3;
+}
+function shouldForceReplay(replayState, options) {
+	return options && options.force && replayState === SessionReplayState.OFF;
+}
+async function notifyWhenSettled(observable, event, promise) {
+	try {
+		return await promise;
+	} finally {
+		observable.notify(event);
+	}
+}
+//#endregion
+export { createPostStartStrategy };
+
+//# sourceMappingURL=postStartStrategy.mjs.map

package/esm/boot/postStartStrategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postStartStrategy.mjs","names":[],"sources":["../../src/boot/postStartStrategy.ts"],"sourcesContent":["import type {\n  LifeCycle,\n  RumConfiguration,\n  StartRecordingOptions,\n  ViewHistory,\n} from '@kubesense/kubesense-browser-rum-core'\nimport {\n  LifeCycleEventType,\n  SessionReplayState,\n  computeSessionReplayState,\n  getRoutePath,\n  isRouteRecordable,\n} from '@kubesense/kubesense-browser-rum-core'\nimport type { Telemetry, DeflateEncoder, SessionManager } from '@kubesense/kubesense-browser-core'\nimport { monitorError } from '@kubesense/kubesense-js-core/monitor'\nimport { asyncRunOnReadyState, Observable } from '@kubesense/kubesense-browser-core'\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink'\nimport { startRecorderInitTelemetry } from '../domain/startRecorderInitTelemetry'\nimport type { startRecording } from './kubesenseRecorder'\nimport { lazyLoadRecorder } from './lazyLoadRecorder'\n\nexport type StartRecording = typeof startRecording\n\nexport const enum RecorderStatus {\n  // The recorder is stopped.\n  Stopped,\n  // The user started the recording while it wasn't possible yet. The recorder should start as soon\n  // as possible.\n  IntentToStart,\n  // The recorder is starting. It does not record anything yet.\n  Starting,\n  // The recorder is started, it records the session.\n  Started,\n}\n\nexport type RecorderInitEvent =\n  | { type: 'start'; forced: boolean }\n  | { type: 'document-ready' }\n  | { type: 'recorder-settled' }\n  | { type: 'aborted' }\n  | { type: 'deflate-encoder-load-failed' }\n  | { type: 'recorder-load-failed' }\n  | { type: 'succeeded' }\n\nexport interface Strategy {\n  start: (options?: StartRecordingOptions) => void\n  stop: () => void\n  isRecording: () => boolean\n  getSessionReplayLink: () => string | undefined\n}\n\nexport function createPostStartStrategy(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  sessionManager: SessionManager,\n  viewHistory: ViewHistory,\n  getOrCreateDeflateEncoder: () => DeflateEncoder | undefined,\n  telemetry: Telemetry\n): Strategy {\n  let status = RecorderStatus.Stopped\n  let stopRecording: () => void\n\n  lifeCycle.subscribe(LifeCycleEventType.SESSION_EXPIRED, () => {\n    if (status === RecorderStatus.Starting || status === RecorderStatus.Started) {\n      stop()\n      status = RecorderStatus.IntentToStart\n    }\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {\n    if (status === RecorderStatus.IntentToStart) {\n      start()\n    }\n  })\n\n  if (configuration.sessionReplayRoutes) {\n    // Route-scoped recording: re-evaluate on every view so a single-page application starts and\n    // stops recording as the user navigates. Each start emits a fresh full snapshot, so every\n    // recorded stretch is a self-contained, replayable segment.\n    lifeCycle.subscribe(LifeCycleEventType.VIEW_CREATED, () => {\n      if (isRouteRecordable(configuration.sessionReplayRoutes, getRoutePath())) {\n        start()\n      } else {\n        stop()\n      }\n    })\n  }\n\n  const observable = new Observable<RecorderInitEvent>()\n  startRecorderInitTelemetry(telemetry, observable)\n\n  const doStart = async (forced: boolean) => {\n    observable.notify({ type: 'start', forced })\n\n    const [startRecordingImpl] = await Promise.all([\n      notifyWhenSettled(observable, { type: 'recorder-settled' }, lazyLoadRecorder()),\n      notifyWhenSettled(observable, { type: 'document-ready' }, asyncRunOnReadyState('interactive')),\n    ])\n\n    if (status !== RecorderStatus.Starting) {\n      observable.notify({ type: 'aborted' })\n      return\n    }\n\n    if (!startRecordingImpl) {\n      status = RecorderStatus.Stopped\n      observable.notify({ type: 'recorder-load-failed' })\n      return\n    }\n\n    const deflateEncoder = getOrCreateDeflateEncoder()\n    if (!deflateEncoder) {\n      status = RecorderStatus.Stopped\n      observable.notify({ type: 'deflate-encoder-load-failed' })\n      return\n    }\n\n    ;({ stop: stopRecording } = startRecordingImpl(\n      lifeCycle,\n      configuration,\n      sessionManager,\n      viewHistory,\n      deflateEncoder,\n      telemetry\n    ))\n\n    status = RecorderStatus.Started\n    observable.notify({ type: 'succeeded' })\n  }\n\n  function start(options?: StartRecordingOptions) {\n    // Route rules gate the automatic start at init and manual `startSessionReplayRecording()`\n    // calls alike, so recording can never begin on a route the configuration excludes. `force`\n    // stays an explicit escape hatch, as it already is for session sampling.\n    if (!options?.force && !isRouteRecordable(configuration.sessionReplayRoutes, getRoutePath())) {\n      return\n    }\n\n    const session = sessionManager.findTrackedSession()\n    const replayState = session ? computeSessionReplayState(session, configuration) : undefined\n\n    if (!canStartRecording(replayState, options)) {\n      status = RecorderStatus.IntentToStart\n      return\n    }\n\n    if (isRecordingInProgress(status)) {\n      return\n    }\n\n    status = RecorderStatus.Starting\n\n    const forced = shouldForceReplay(replayState, options) || false\n\n    // Intentionally not awaiting doStart() to keep it asynchronous\n    doStart(forced).catch(monitorError)\n\n    if (forced) {\n      sessionManager.updateSessionState({ forcedReplay: '1' })\n    }\n  }\n\n  function stop() {\n    if (status === RecorderStatus.Started) {\n      stopRecording?.()\n    }\n\n    status = RecorderStatus.Stopped\n  }\n\n  return {\n    start,\n    stop,\n    getSessionReplayLink() {\n      return getSessionReplayLink(configuration, sessionManager, viewHistory, status !== RecorderStatus.Stopped)\n    },\n    isRecording: () => status === RecorderStatus.Started,\n  }\n}\n\nfunction canStartRecording(replayState: SessionReplayState | undefined, options?: StartRecordingOptions) {\n  return replayState !== undefined && (replayState !== SessionReplayState.OFF || options?.force)\n}\n\nfunction isRecordingInProgress(status: RecorderStatus) {\n  return status === RecorderStatus.Starting || status === RecorderStatus.Started\n}\n\nfunction shouldForceReplay(replayState: SessionReplayState | undefined, options?: StartRecordingOptions) {\n  return options && options.force && replayState === SessionReplayState.OFF\n}\n\nasync function notifyWhenSettled<Event, Result>(\n  observable: Observable<Event>,\n  event: Event,\n  promise: Promise<Result>\n): Promise<Result> {\n  try {\n    return await promise\n  } finally {\n    observable.notify(event)\n  }\n}\n"],"mappings":";;;;;;;AAmDA,SAAgB,wBACd,eACA,WACA,gBACA,aACA,2BACA,WACU;CACV,IAAI,SAAA;CACJ,IAAI;CAEJ,UAAU,UAAU,mBAAmB,uBAAuB;EAC5D,IAAI,WAAA,KAAsC,WAAA,GAAmC;GAC3E,KAAK;GACL,SAAA;EACF;CACF,CAAC;CAED,UAAU,UAAU,mBAAmB,uBAAuB;EAC5D,IAAI,WAAA,GACF,MAAM;CAEV,CAAC;CAED,IAAI,cAAc,qBAIhB,UAAU,UAAU,mBAAmB,oBAAoB;EACzD,IAAI,kBAAkB,cAAc,qBAAqB,aAAa,CAAC,GACrE,MAAM;OAEN,KAAK;CAET,CAAC;CAGH,MAAM,aAAa,IAAI,WAA8B;CACrD,2BAA2B,WAAW,UAAU;CAEhD,MAAM,UAAU,OAAO,WAAoB;EACzC,WAAW,OAAO;GAAE,MAAM;GAAS;EAAO,CAAC;EAE3C,MAAM,CAAC,sBAAsB,MAAM,QAAQ,IAAI,CAC7C,kBAAkB,YAAY,EAAE,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,GAC9E,kBAAkB,YAAY,EAAE,MAAM,iBAAiB,GAAG,qBAAqB,aAAa,CAAC,CAC/F,CAAC;EAED,IAAI,WAAA,GAAoC;GACtC,WAAW,OAAO,EAAE,MAAM,UAAU,CAAC;GACrC;EACF;EAEA,IAAI,CAAC,oBAAoB;GACvB,SAAA;GACA,WAAW,OAAO,EAAE,MAAM,uBAAuB,CAAC;GAClD;EACF;EAEA,MAAM,iBAAiB,0BAA0B;EACjD,IAAI,CAAC,gBAAgB;GACnB,SAAA;GACA,WAAW,OAAO,EAAE,MAAM,8BAA8B,CAAC;GACzD;EACF;EAEC,CAAC,CAAE,MAAM,iBAAkB,mBAC1B,WACA,eACA,gBACA,aACA,gBACA,SACF;EAEA,SAAA;EACA,WAAW,OAAO,EAAE,MAAM,YAAY,CAAC;CACzC;CAEA,SAAS,MAAM,SAAiC;EAI9C,IAAI,CAAC,SAAS,SAAS,CAAC,kBAAkB,cAAc,qBAAqB,aAAa,CAAC,GACzF;EAGF,MAAM,UAAU,eAAe,mBAAmB;EAClD,MAAM,cAAc,UAAU,0BAA0B,SAAS,aAAa,IAAI,KAAA;EAElF,IAAI,CAAC,kBAAkB,aAAa,OAAO,GAAG;GAC5C,SAAA;GACA;EACF;EAEA,IAAI,sBAAsB,MAAM,GAC9B;EAGF,SAAA;EAEA,MAAM,SAAS,kBAAkB,aAAa,OAAO,KAAK;EAG1D,QAAQ,MAAM,CAAC,CAAC,MAAM,YAAY;EAElC,IAAI,QACF,eAAe,mBAAmB,EAAE,cAAc,IAAI,CAAC;CAE3D;CAEA,SAAS,OAAO;EACd,IAAI,WAAA,GACF,gBAAgB;EAGlB,SAAA;CACF;CAEA,OAAO;EACL;EACA;EACA,uBAAuB;GACrB,OAAO,qBAAqB,eAAe,gBAAgB,aAAa,WAAA,CAAiC;EAC3G;EACA,mBAAmB,WAAA;CACrB;AACF;AAEA,SAAS,kBAAkB,aAA6C,SAAiC;CACvG,OAAO,gBAAgB,KAAA,MAAc,gBAAgB,mBAAmB,OAAO,SAAS;AAC1F;AAEA,SAAS,sBAAsB,QAAwB;CACrD,OAAO,WAAA,KAAsC,WAAA;AAC/C;AAEA,SAAS,kBAAkB,aAA6C,SAAiC;CACvG,OAAO,WAAW,QAAQ,SAAS,gBAAgB,mBAAmB;AACxE;AAEA,eAAe,kBACb,YACA,OACA,SACiB;CACjB,IAAI;EACF,OAAO,MAAM;CACf,UAAU;EACR,WAAW,OAAO,KAAK;CACzB;AACF"}

package/esm/boot/preStartStrategy.mjs

@@ -0,0 +1,24 @@
+import { noop } from "@kubesense/kubesense-browser-core";
+//#region src/boot/preStartStrategy.ts
+function createPreStartStrategy() {
+	let status = 0;
+	return {
+		strategy: {
+			start() {
+				status = 1;
+			},
+			stop() {
+				status = 2;
+			},
+			isRecording: () => false,
+			getSessionReplayLink: noop
+		},
+		shouldStartImmediately(configuration) {
+			return status === 1 || status === 0 && !configuration.startSessionReplayRecordingManually;
+		}
+	};
+}
+//#endregion
+export { createPreStartStrategy };
+
+//# sourceMappingURL=preStartStrategy.mjs.map

package/esm/boot/preStartStrategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"preStartStrategy.mjs","names":[],"sources":["../../src/boot/preStartStrategy.ts"],"sourcesContent":["import { noop } from '@kubesense/kubesense-browser-core'\nimport type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core'\nimport type { Strategy } from './postStartStrategy'\n\nconst enum PreStartRecorderStatus {\n  None,\n  HadManualStart,\n  HadManualStop,\n}\n\nexport function createPreStartStrategy(): {\n  strategy: Strategy\n  shouldStartImmediately: (configuration: RumConfiguration) => boolean\n} {\n  let status = PreStartRecorderStatus.None\n  return {\n    strategy: {\n      start() {\n        status = PreStartRecorderStatus.HadManualStart\n      },\n      stop() {\n        status = PreStartRecorderStatus.HadManualStop\n      },\n      isRecording: () => false,\n      getSessionReplayLink: noop as () => string | undefined,\n    },\n    shouldStartImmediately(configuration) {\n      return (\n        status === PreStartRecorderStatus.HadManualStart ||\n        (status === PreStartRecorderStatus.None && !configuration.startSessionReplayRecordingManually)\n      )\n    },\n  }\n}\n"],"mappings":";;AAUA,SAAgB,yBAGd;CACA,IAAI,SAAA;CACJ,OAAO;EACL,UAAU;GACR,QAAQ;IACN,SAAA;GACF;GACA,OAAO;IACL,SAAA;GACF;GACA,mBAAmB;GACnB,sBAAsB;EACxB;EACA,uBAAuB,eAAe;GACpC,OACE,WAAA,KACC,WAAA,KAA0C,CAAC,cAAc;EAE9D;CACF;AACF"}

package/esm/boot/profilerApi.mjs

@@ -0,0 +1,47 @@
+import { isProfilingSupported } from "../domain/profiling/profilingSupported.mjs";
+import { startProfilingContext } from "../domain/profiling/profilingContext.mjs";
+import { lazyLoadProfiler } from "./lazyLoadProfiler.mjs";
+import { BridgeCapability, bridgeSupports, canUseEventBridge, correctedChildSampleRate, isSampled, mockable } from "@kubesense/kubesense-browser-core";
+import { monitorError } from "@kubesense/kubesense-js-core/monitor";
+//#region src/boot/profilerApi.ts
+function makeProfilerApi() {
+	let profiler;
+	function onRumStart(lifeCycle, hooks, configuration, sessionManager, viewHistory, createEncoder) {
+		const session = sessionManager.findTrackedSession();
+		if (!session) return;
+		if (!isProfilingSampled(configuration, session)) return;
+		const profilingContextManager = startProfilingContext(hooks);
+		if (!mockable(isProfilingSupported)()) {
+			profilingContextManager.set({
+				status: "error",
+				error_reason: "not-supported-by-browser"
+			});
+			return;
+		}
+		mockable(lazyLoadProfiler)().then((createRumProfiler) => {
+			if (!createRumProfiler) {
+				profilingContextManager.set({
+					status: "error",
+					error_reason: "failed-to-lazy-load"
+				});
+				return;
+			}
+			profiler = createRumProfiler(configuration, lifeCycle, sessionManager, profilingContextManager, createEncoder, viewHistory, void 0);
+			profiler.start();
+		}).catch(monitorError);
+	}
+	return {
+		onRumStart,
+		stop: () => {
+			profiler?.stop();
+		}
+	};
+}
+function isProfilingSampled(configuration, session) {
+	if (canUseEventBridge()) return bridgeSupports(BridgeCapability.PROFILES);
+	return isSampled(session.id, correctedChildSampleRate(configuration.sessionSampleRate, configuration.profilingSampleRate));
+}
+//#endregion
+export { makeProfilerApi };
+
+//# sourceMappingURL=profilerApi.mjs.map

package/esm/boot/profilerApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"profilerApi.mjs","names":[],"sources":["../../src/boot/profilerApi.ts"],"sourcesContent":["import type {\n  Hooks,\n  LifeCycle,\n  ProfilerApi,\n  RumConfiguration,\n  ViewHistory,\n} from '@kubesense/kubesense-browser-rum-core'\nimport type { DeflateEncoderStreamId, Encoder, SessionContext, SessionManager } from '@kubesense/kubesense-browser-core'\nimport {\n  BridgeCapability,\n  bridgeSupports,\n  canUseEventBridge,\n  correctedChildSampleRate,\n  isSampled,\n  mockable,\n} from '@kubesense/kubesense-browser-core'\nimport { monitorError } from '@kubesense/kubesense-js-core/monitor'\nimport type { RUMProfiler } from '../domain/profiling/types'\nimport { isProfilingSupported } from '../domain/profiling/profilingSupported'\nimport { startProfilingContext } from '../domain/profiling/profilingContext'\nimport { lazyLoadProfiler } from './lazyLoadProfiler'\n\nexport function makeProfilerApi(): ProfilerApi {\n  let profiler: RUMProfiler | undefined\n\n  function onRumStart(\n    lifeCycle: LifeCycle,\n    hooks: Hooks,\n    configuration: RumConfiguration,\n    sessionManager: SessionManager,\n    viewHistory: ViewHistory,\n    createEncoder: (streamId: DeflateEncoderStreamId) => Encoder\n  ) {\n    const session = sessionManager.findTrackedSession() // Check if the session is tracked.\n\n    if (!session) {\n      // No session tracked, no profiling.\n      // Note: No Profiling context is set at this stage.\n      return\n    }\n\n    if (!isProfilingSampled(configuration, session)) {\n      return\n    }\n\n    // Listen to events and add the profiling context to them.\n    const profilingContextManager = startProfilingContext(hooks)\n\n    // Browser support check\n    if (!mockable(isProfilingSupported)()) {\n      profilingContextManager.set({\n        status: 'error',\n        error_reason: 'not-supported-by-browser',\n      })\n      return\n    }\n\n    mockable(lazyLoadProfiler)()\n      .then((createRumProfiler) => {\n        if (!createRumProfiler) {\n          profilingContextManager.set({ status: 'error', error_reason: 'failed-to-lazy-load' })\n          return\n        }\n\n        profiler = createRumProfiler(\n          configuration,\n          lifeCycle,\n          sessionManager,\n          profilingContextManager,\n          createEncoder,\n          viewHistory,\n          undefined\n        )\n        profiler.start()\n      })\n      .catch(monitorError)\n  }\n\n  return {\n    onRumStart,\n    stop: () => {\n      profiler?.stop()\n    },\n  }\n}\n\nfunction isProfilingSampled(configuration: RumConfiguration, session: SessionContext) {\n  if (canUseEventBridge()) {\n    // In bridge mode, native SDK owns the sampling decision, skip the rate check\n    return bridgeSupports(BridgeCapability.PROFILES)\n  }\n  return isSampled(\n    session.id,\n    correctedChildSampleRate(configuration.sessionSampleRate, configuration.profilingSampleRate)\n  )\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,kBAA+B;CAC7C,IAAI;CAEJ,SAAS,WACP,WACA,OACA,eACA,gBACA,aACA,eACA;EACA,MAAM,UAAU,eAAe,mBAAmB;EAElD,IAAI,CAAC,SAGH;EAGF,IAAI,CAAC,mBAAmB,eAAe,OAAO,GAC5C;EAIF,MAAM,0BAA0B,sBAAsB,KAAK;EAG3D,IAAI,CAAC,SAAS,oBAAoB,CAAC,CAAC,GAAG;GACrC,wBAAwB,IAAI;IAC1B,QAAQ;IACR,cAAc;GAChB,CAAC;GACD;EACF;EAEA,SAAS,gBAAgB,CAAC,CAAC,CAAC,CACzB,MAAM,sBAAsB;GAC3B,IAAI,CAAC,mBAAmB;IACtB,wBAAwB,IAAI;KAAE,QAAQ;KAAS,cAAc;IAAsB,CAAC;IACpF;GACF;GAEA,WAAW,kBACT,eACA,WACA,gBACA,yBACA,eACA,aACA,KAAA,CACF;GACA,SAAS,MAAM;EACjB,CAAC,CAAC,CACD,MAAM,YAAY;CACvB;CAEA,OAAO;EACL;EACA,YAAY;GACV,UAAU,KAAK;EACjB;CACF;AACF;AAEA,SAAS,mBAAmB,eAAiC,SAAyB;CACpF,IAAI,kBAAkB,GAEpB,OAAO,eAAe,iBAAiB,QAAQ;CAEjD,OAAO,UACL,QAAQ,IACR,yBAAyB,cAAc,mBAAmB,cAAc,mBAAmB,CAC7F;AACF"}

package/esm/boot/recorderApi.mjs

@@ -0,0 +1,43 @@
+import { getReplayStats } from "../domain/replayStats.mjs";
+import { createDeflateEncoder } from "../domain/deflate/deflateEncoder.mjs";
+import { getDeflateWorkerStatus, startDeflateWorker } from "../domain/deflate/deflateWorker.mjs";
+import "../domain/deflate/index.mjs";
+import { createPostStartStrategy } from "./postStartStrategy.mjs";
+import { createPreStartStrategy } from "./preStartStrategy.mjs";
+import { BridgeCapability, DeflateEncoderStreamId, bridgeSupports, canUseEventBridge, noop } from "@kubesense/kubesense-browser-core";
+//#region src/boot/recorderApi.ts
+function makeRecorderApi() {
+	if (canUseEventBridge() && !bridgeSupports(BridgeCapability.RECORDS)) return {
+		start: noop,
+		stop: noop,
+		getReplayStats: () => void 0,
+		onRumStart: noop,
+		isRecording: () => false,
+		getSessionReplayLink: () => void 0
+	};
+	let { strategy, shouldStartImmediately } = createPreStartStrategy();
+	return {
+		start: (options) => strategy.start(options),
+		stop: () => strategy.stop(),
+		getSessionReplayLink: () => strategy.getSessionReplayLink(),
+		onRumStart,
+		isRecording: () => getDeflateWorkerStatus() === 3 && strategy.isRecording(),
+		getReplayStats: (viewId) => getDeflateWorkerStatus() === 3 ? getReplayStats(viewId) : void 0
+	};
+	function onRumStart(lifeCycle, configuration, sessionManager, viewHistory, worker, telemetry) {
+		let cachedDeflateEncoder;
+		function getOrCreateDeflateEncoder() {
+			if (!cachedDeflateEncoder) {
+				worker ??= startDeflateWorker(configuration, "KubeSense Session Replay", () => strategy.stop());
+				if (worker) cachedDeflateEncoder = createDeflateEncoder(worker, DeflateEncoderStreamId.REPLAY);
+			}
+			return cachedDeflateEncoder;
+		}
+		strategy = createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, getOrCreateDeflateEncoder, telemetry);
+		if (shouldStartImmediately(configuration)) strategy.start();
+	}
+}
+//#endregion
+export { makeRecorderApi };
+
+//# sourceMappingURL=recorderApi.mjs.map

package/esm/boot/recorderApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorderApi.mjs","names":["getReplayStatsImpl"],"sources":["../../src/boot/recorderApi.ts"],"sourcesContent":["import type { DeflateEncoder, DeflateWorker, Telemetry, SessionManager } from '@kubesense/kubesense-browser-core'\nimport {\n  canUseEventBridge,\n  noop,\n  BridgeCapability,\n  bridgeSupports,\n  DeflateEncoderStreamId,\n} from '@kubesense/kubesense-browser-core'\nimport type {\n  LifeCycle,\n  ViewHistory,\n  RecorderApi,\n  RumConfiguration,\n  StartRecordingOptions,\n} from '@kubesense/kubesense-browser-rum-core'\nimport { getReplayStats as getReplayStatsImpl } from '../domain/replayStats'\nimport {\n  createDeflateEncoder,\n  DeflateWorkerStatus,\n  getDeflateWorkerStatus,\n  startDeflateWorker,\n} from '../domain/deflate'\nimport { createPostStartStrategy } from './postStartStrategy'\nimport { createPreStartStrategy } from './preStartStrategy'\n\nexport function makeRecorderApi(): RecorderApi {\n  if (canUseEventBridge() && !bridgeSupports(BridgeCapability.RECORDS)) {\n    return {\n      start: noop,\n      stop: noop,\n      getReplayStats: () => undefined,\n      onRumStart: noop,\n      isRecording: () => false,\n      getSessionReplayLink: () => undefined,\n    }\n  }\n\n  // eslint-disable-next-line prefer-const\n  let { strategy, shouldStartImmediately } = createPreStartStrategy()\n\n  return {\n    start: (options?: StartRecordingOptions) => strategy.start(options),\n    stop: () => strategy.stop(),\n    getSessionReplayLink: () => strategy.getSessionReplayLink(),\n    onRumStart,\n    isRecording: () =>\n      // The worker is started optimistically, meaning we could have started to record but its\n      // initialization fails a bit later. This could happen when:\n      // * the worker URL (blob or plain URL) is blocked by CSP in Firefox only (Chromium and Safari\n      // throw an exception when instantiating the worker, and IE doesn't care about CSP)\n      // * the browser fails to load the worker in case the workerUrl is used\n      // * an unexpected error occurs in the Worker before initialization, ex:\n      //   * a runtime exception collected by monitor()\n      //   * a syntax error notified by the browser via an error event\n      // * the worker is unresponsive for some reason and timeouts\n      //\n      // It is not expected to happen often. Nonetheless, the \"replayable\" status on RUM events is\n      // an important part of the KubeSense App:\n      // * If we have a false positive (we set has_replay: true even if no replay data is present),\n      // we might display broken links to the Session Replay player.\n      // * If we have a false negative (we don't set has_replay: true even if replay data is\n      // available), it is less noticeable because no link will be displayed.\n      //\n      // Thus, it is better to have false negative, so let's make sure the worker is correctly\n      // initialized before advertizing that we are recording.\n      //\n      // In the future, when the compression worker will also be used for RUM data, this will be\n      // less important since no RUM event will be sent when the worker fails to initialize.\n      getDeflateWorkerStatus() === DeflateWorkerStatus.Initialized && strategy.isRecording(),\n\n    getReplayStats: (viewId) =>\n      getDeflateWorkerStatus() === DeflateWorkerStatus.Initialized ? getReplayStatsImpl(viewId) : undefined,\n  }\n\n  function onRumStart(\n    lifeCycle: LifeCycle,\n    configuration: RumConfiguration,\n    sessionManager: SessionManager,\n    viewHistory: ViewHistory,\n    worker: DeflateWorker | undefined,\n    telemetry: Telemetry\n  ) {\n    let cachedDeflateEncoder: DeflateEncoder | undefined\n\n    function getOrCreateDeflateEncoder() {\n      if (!cachedDeflateEncoder) {\n        worker ??= startDeflateWorker(configuration, 'KubeSense Session Replay', () => strategy.stop())\n\n        if (worker) {\n          cachedDeflateEncoder = createDeflateEncoder(worker, DeflateEncoderStreamId.REPLAY)\n        }\n      }\n      return cachedDeflateEncoder\n    }\n\n    strategy = createPostStartStrategy(\n      configuration,\n      lifeCycle,\n      sessionManager,\n      viewHistory,\n      getOrCreateDeflateEncoder,\n      telemetry\n    )\n\n    if (shouldStartImmediately(configuration)) {\n      strategy.start()\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAyBA,SAAgB,kBAA+B;CAC7C,IAAI,kBAAkB,KAAK,CAAC,eAAe,iBAAiB,OAAO,GACjE,OAAO;EACL,OAAO;EACP,MAAM;EACN,sBAAsB,KAAA;EACtB,YAAY;EACZ,mBAAmB;EACnB,4BAA4B,KAAA;CAC9B;CAIF,IAAI,EAAE,UAAU,2BAA2B,uBAAuB;CAElE,OAAO;EACL,QAAQ,YAAoC,SAAS,MAAM,OAAO;EAClE,YAAY,SAAS,KAAK;EAC1B,4BAA4B,SAAS,qBAAqB;EAC1D;EACA,mBAuBE,uBAAuB,MAAA,KAAyC,SAAS,YAAY;EAEvF,iBAAiB,WACf,uBAAuB,MAAA,IAAwCA,eAAmB,MAAM,IAAI,KAAA;CAChG;CAEA,SAAS,WACP,WACA,eACA,gBACA,aACA,QACA,WACA;EACA,IAAI;EAEJ,SAAS,4BAA4B;GACnC,IAAI,CAAC,sBAAsB;IACzB,WAAW,mBAAmB,eAAe,kCAAkC,SAAS,KAAK,CAAC;IAE9F,IAAI,QACF,uBAAuB,qBAAqB,QAAQ,uBAAuB,MAAM;GAErF;GACA,OAAO;EACT;EAEA,WAAW,wBACT,eACA,WACA,gBACA,aACA,2BACA,SACF;EAEA,IAAI,uBAAuB,aAAa,GACtC,SAAS,MAAM;CAEnB;AACF"}

package/esm/domain/deflate/deflateEncoder.mjs

@@ -0,0 +1,96 @@
+import { addEventListener, concatBuffers } from "@kubesense/kubesense-browser-core";
+//#region src/domain/deflate/deflateEncoder.ts
+function createDeflateEncoder(worker, streamId) {
+	let rawBytesCount = 0;
+	let compressedData = [];
+	let compressedDataTrailer;
+	let isEmpty = true;
+	let nextWriteActionId = 0;
+	const pendingWriteActions = [];
+	const expectedStreamId = streamId;
+	const { stop: removeMessageListener } = addEventListener(worker, "message", ({ data: workerResponse }) => {
+		if (workerResponse.type !== "wrote" || workerResponse.streamId !== expectedStreamId) return;
+		const nextPendingAction = pendingWriteActions[0];
+		if (nextPendingAction) {
+			if (nextPendingAction.id === workerResponse.id) {
+				pendingWriteActions.shift();
+				rawBytesCount += workerResponse.additionalBytesCount;
+				compressedData.push(workerResponse.result);
+				compressedDataTrailer = workerResponse.trailer;
+				if (nextPendingAction.writeCallback) nextPendingAction.writeCallback(workerResponse.result.byteLength);
+				else if (nextPendingAction.finishCallback) nextPendingAction.finishCallback();
+			} else if (nextPendingAction.id < workerResponse.id) removeMessageListener();
+		}
+	});
+	function consumeResult() {
+		const output = compressedData.length === 0 ? /* @__PURE__ */ new Uint8Array(0) : concatBuffers(compressedData.concat(compressedDataTrailer));
+		const result = {
+			rawBytesCount,
+			output,
+			outputBytesCount: output.byteLength,
+			encoding: "deflate"
+		};
+		rawBytesCount = 0;
+		compressedData = [];
+		return result;
+	}
+	function sendResetIfNeeded() {
+		if (!isEmpty) {
+			worker.postMessage({
+				action: "reset",
+				streamId
+			});
+			isEmpty = true;
+		}
+	}
+	return {
+		isAsync: true,
+		get isEmpty() {
+			return isEmpty;
+		},
+		write(data, callback) {
+			worker.postMessage({
+				action: "write",
+				id: nextWriteActionId,
+				data,
+				streamId
+			});
+			pendingWriteActions.push({
+				id: nextWriteActionId,
+				writeCallback: callback,
+				data
+			});
+			isEmpty = false;
+			nextWriteActionId += 1;
+		},
+		finish(callback) {
+			sendResetIfNeeded();
+			if (!pendingWriteActions.length) callback(consumeResult());
+			else {
+				pendingWriteActions.forEach((pendingWriteAction) => {
+					delete pendingWriteAction.writeCallback;
+				});
+				pendingWriteActions[pendingWriteActions.length - 1].finishCallback = () => callback(consumeResult());
+			}
+		},
+		finishSync() {
+			sendResetIfNeeded();
+			const pendingData = pendingWriteActions.map((pendingWriteAction) => pendingWriteAction.data).join("");
+			pendingWriteActions.length = 0;
+			return {
+				...consumeResult(),
+				pendingData
+			};
+		},
+		estimateEncodedBytesCount(data) {
+			return data.length / 8;
+		},
+		stop() {
+			removeMessageListener();
+		}
+	};
+}
+//#endregion
+export { createDeflateEncoder };
+
+//# sourceMappingURL=deflateEncoder.mjs.map

package/esm/domain/deflate/deflateEncoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deflateEncoder.mjs","names":[],"sources":["../../../src/domain/deflate/deflateEncoder.ts"],"sourcesContent":["import type {\n  DeflateWorkerResponse,\n  DeflateEncoder,\n  DeflateEncoderStreamId,\n  DeflateWorker,\n  EncoderResult,\n  Uint8ArrayBuffer,\n} from '@kubesense/kubesense-browser-core'\nimport { addEventListener, concatBuffers } from '@kubesense/kubesense-browser-core'\n\nexport function createDeflateEncoder(worker: DeflateWorker, streamId: DeflateEncoderStreamId): DeflateEncoder {\n  let rawBytesCount = 0\n  let compressedData: Uint8ArrayBuffer[] = []\n  let compressedDataTrailer: Uint8ArrayBuffer\n\n  let isEmpty = true\n  let nextWriteActionId = 0\n  const pendingWriteActions: Array<{\n    writeCallback?: (additionalEncodedBytesCount: number) => void\n    finishCallback?: () => void\n    id: number\n    data: string\n  }> = []\n\n  const expectedStreamId: number = streamId\n  const { stop: removeMessageListener } = addEventListener(\n    worker,\n    'message',\n    ({ data: workerResponse }: MessageEvent<DeflateWorkerResponse>) => {\n      if (workerResponse.type !== 'wrote' || workerResponse.streamId !== expectedStreamId) {\n        return\n      }\n\n      const nextPendingAction = pendingWriteActions[0]\n      if (nextPendingAction) {\n        if (nextPendingAction.id === workerResponse.id) {\n          pendingWriteActions.shift()\n\n          rawBytesCount += workerResponse.additionalBytesCount\n          compressedData.push(workerResponse.result)\n          compressedDataTrailer = workerResponse.trailer\n\n          if (nextPendingAction.writeCallback) {\n            nextPendingAction.writeCallback(workerResponse.result.byteLength)\n          } else if (nextPendingAction.finishCallback) {\n            nextPendingAction.finishCallback()\n          }\n        } else if (nextPendingAction.id < workerResponse.id) {\n          // Worker responses received out of order\n          removeMessageListener()\n        }\n      }\n    }\n  )\n\n  function consumeResult(): EncoderResult<Uint8ArrayBuffer> {\n    const output =\n      compressedData.length === 0 ? new Uint8Array(0) : concatBuffers(compressedData.concat(compressedDataTrailer))\n    const result: EncoderResult<Uint8ArrayBuffer> = {\n      rawBytesCount,\n      output,\n      outputBytesCount: output.byteLength,\n      encoding: 'deflate',\n    }\n    rawBytesCount = 0\n    compressedData = []\n    return result\n  }\n\n  function sendResetIfNeeded() {\n    if (!isEmpty) {\n      worker.postMessage({\n        action: 'reset',\n        streamId,\n      })\n      isEmpty = true\n    }\n  }\n\n  return {\n    isAsync: true,\n\n    get isEmpty() {\n      return isEmpty\n    },\n\n    write(data, callback) {\n      worker.postMessage({\n        action: 'write',\n        id: nextWriteActionId,\n        data,\n        streamId,\n      })\n      pendingWriteActions.push({\n        id: nextWriteActionId,\n        writeCallback: callback,\n        data,\n      })\n      isEmpty = false\n      nextWriteActionId += 1\n    },\n\n    finish(callback) {\n      sendResetIfNeeded()\n\n      if (!pendingWriteActions.length) {\n        callback(consumeResult())\n      } else {\n        // Make sure we do not call any write callback\n        pendingWriteActions.forEach((pendingWriteAction) => {\n          delete pendingWriteAction.writeCallback\n        })\n\n        // Wait for the last action to finish before calling the finish callback\n        pendingWriteActions[pendingWriteActions.length - 1].finishCallback = () => callback(consumeResult())\n      }\n    },\n\n    finishSync() {\n      sendResetIfNeeded()\n      const pendingData = pendingWriteActions.map((pendingWriteAction) => pendingWriteAction.data).join('')\n      // Ignore all pending write actions responses from the worker\n      pendingWriteActions.length = 0\n      return { ...consumeResult(), pendingData }\n    },\n\n    estimateEncodedBytesCount(data) {\n      // This is a rough estimation of the data size once it'll be encoded by deflate. We observed\n      // that if it's the first chunk of data pushed to the stream, the ratio is lower (3-4), but\n      // after that the ratio is greater (10+). We chose 8 here, which (on average) seems to produce\n      // requests of the expected size.\n      return data.length / 8\n    },\n\n    stop() {\n      removeMessageListener()\n    },\n  }\n}\n"],"mappings":";;AAUA,SAAgB,qBAAqB,QAAuB,UAAkD;CAC5G,IAAI,gBAAgB;CACpB,IAAI,iBAAqC,CAAC;CAC1C,IAAI;CAEJ,IAAI,UAAU;CACd,IAAI,oBAAoB;CACxB,MAAM,sBAKD,CAAC;CAEN,MAAM,mBAA2B;CACjC,MAAM,EAAE,MAAM,0BAA0B,iBACtC,QACA,YACC,EAAE,MAAM,qBAA0D;EACjE,IAAI,eAAe,SAAS,WAAW,eAAe,aAAa,kBACjE;EAGF,MAAM,oBAAoB,oBAAoB;EAC9C,IAAI,mBAAmB;GACrB,IAAI,kBAAkB,OAAO,eAAe,IAAI;IAC9C,oBAAoB,MAAM;IAE1B,iBAAiB,eAAe;IAChC,eAAe,KAAK,eAAe,MAAM;IACzC,wBAAwB,eAAe;IAEvC,IAAI,kBAAkB,eACpB,kBAAkB,cAAc,eAAe,OAAO,UAAU;SAC3D,IAAI,kBAAkB,gBAC3B,kBAAkB,eAAe;GAErC,OAAO,IAAI,kBAAkB,KAAK,eAAe,IAE/C,sBAAsB;EAE1B;CACF,CACF;CAEA,SAAS,gBAAiD;EACxD,MAAM,SACJ,eAAe,WAAW,oBAAI,IAAI,WAAW,CAAC,IAAI,cAAc,eAAe,OAAO,qBAAqB,CAAC;EAC9G,MAAM,SAA0C;GAC9C;GACA;GACA,kBAAkB,OAAO;GACzB,UAAU;EACZ;EACA,gBAAgB;EAChB,iBAAiB,CAAC;EAClB,OAAO;CACT;CAEA,SAAS,oBAAoB;EAC3B,IAAI,CAAC,SAAS;GACZ,OAAO,YAAY;IACjB,QAAQ;IACR;GACF,CAAC;GACD,UAAU;EACZ;CACF;CAEA,OAAO;EACL,SAAS;EAET,IAAI,UAAU;GACZ,OAAO;EACT;EAEA,MAAM,MAAM,UAAU;GACpB,OAAO,YAAY;IACjB,QAAQ;IACR,IAAI;IACJ;IACA;GACF,CAAC;GACD,oBAAoB,KAAK;IACvB,IAAI;IACJ,eAAe;IACf;GACF,CAAC;GACD,UAAU;GACV,qBAAqB;EACvB;EAEA,OAAO,UAAU;GACf,kBAAkB;GAElB,IAAI,CAAC,oBAAoB,QACvB,SAAS,cAAc,CAAC;QACnB;IAEL,oBAAoB,SAAS,uBAAuB;KAClD,OAAO,mBAAmB;IAC5B,CAAC;IAGD,oBAAoB,oBAAoB,SAAS,EAAE,CAAC,uBAAuB,SAAS,cAAc,CAAC;GACrG;EACF;EAEA,aAAa;GACX,kBAAkB;GAClB,MAAM,cAAc,oBAAoB,KAAK,uBAAuB,mBAAmB,IAAI,CAAC,CAAC,KAAK,EAAE;GAEpG,oBAAoB,SAAS;GAC7B,OAAO;IAAE,GAAG,cAAc;IAAG;GAAY;EAC3C;EAEA,0BAA0B,MAAM;GAK9B,OAAO,KAAK,SAAS;EACvB;EAEA,OAAO;GACL,sBAAsB;EACxB;CACF;AACF"}