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

package/src/domain/configuration/index.ts

@@ -1,13 +1,10 @@
-export type { Configuration, InitConfiguration, ProxyFn } from './configuration'
+export type { Configuration, InitConfiguration } from './configuration'
 export {
   DefaultPrivacyLevel,
   TraceContextInjection,
-  isSampleRate,
-  validateAndBuildConfiguration,
   serializeConfiguration,
+  BROWSER_CORE_SCHEMA,
 } from './configuration'
-export type { EndpointBuilder, TrackType } from './endpointBuilder'
-export { createEndpointBuilder, buildEndpointHost } from './endpointBuilder'
 export type { RemoteSdkConfig, RemoteSdkConfigFeatures } from './remoteSdkConfig'
 export {
   SDK_CONFIG_CACHE_KEY,
@@ -18,10 +15,12 @@ export {
   parseSdkConfig,
   readBoolean,
   readEnum,
+  readNumberInRange,
   readSampleRate,
   readString,
+  readStringList,
   refreshSdkConfig,
   setCachedSdkConfig,
 } from './remoteSdkConfig'
-export * from '../intakeSites'
-export { computeTransportConfiguration, isIntakeUrl } from './transportConfiguration'
+export { buildCookieOptions } from '../../browser/cookie'
+export { isAllowedTrackingOrigins } from '../allowedTrackingOrigins'

package/src/domain/configuration/remoteSdkConfig.ts

@@ -1,8 +1,10 @@
+import { monitorError } from '@kubesense/kubesense-js-core/monitor'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
+import { INTAKE_SITE_PROD } from '@kubesense/kubesense-js-core/transport'
 import { generateUUID } from '../../tools/utils/stringUtils'
+import { fetch } from '../../browser/fetch'
 import { display } from '../../tools/display'
-import { monitorError } from '../../tools/monitor'
 import type { InitConfiguration } from './configuration'
-import { buildEndpointHost } from './endpointBuilder'
 
 /**
  * Dashboard-managed SDK settings, served by the Kubesense collector.
@@ -12,7 +14,17 @@ import { buildEndpointHost } from './endpointBuilder'
  * next page load — SDK configuration is frozen at `init()` time by design.
  */
 
+/**
+ * Prefix of the local-storage key holding the cached document. The key carries the client token,
+ * which the collector issues per application, so applications sharing an origin — several apps on
+ * one domain, or `localhost` during development — never read each other's settings. RUM and Logs
+ * of one application share the token, and so still share the document.
+ */
 export const SDK_CONFIG_CACHE_KEY = '_kubesense_sdk_config'
+
+export function sdkConfigCacheKey(clientToken: string) {
+  return `${SDK_CONFIG_CACHE_KEY}_${clientToken}`
+}
 export const SDK_CONFIG_PATH = '/rum/api/v1/sdk-config'
 
 /** Give up rather than let a hung request keep a page-load handle alive. */
@@ -45,10 +57,13 @@ export interface RemoteSdkConfigFeatures {
  * Read the cached document. Synchronous, never touches the network, and never throws: a
  * corrupted or unavailable cache resolves to `undefined` (pure SDK defaults).
  */
-export function getCachedSdkConfig(): RemoteSdkConfig | undefined {
+export function getCachedSdkConfig(clientToken: string): RemoteSdkConfig | undefined {
   let raw: string | null
   try {
-    raw = localStorage.getItem(SDK_CONFIG_CACHE_KEY)
+    // The unscoped key predates per-application caching and may hold another application's
+    // document; it is dropped rather than migrated.
+    localStorage.removeItem(SDK_CONFIG_CACHE_KEY)
+    raw = localStorage.getItem(sdkConfigCacheKey(clientToken))
   } catch {
     // Local storage can be unavailable (disabled, quota, sandboxed iframe).
     return undefined
@@ -61,22 +76,22 @@ export function getCachedSdkConfig(): RemoteSdkConfig | undefined {
   const config = parseSdkConfig(raw)
   if (!config) {
     // Drop a document we can no longer read so we stop paying for it on every page load.
-    clearCachedSdkConfig()
+    clearCachedSdkConfig(clientToken)
   }
   return config
 }
 
-export function setCachedSdkConfig(rawConfig: string) {
+export function setCachedSdkConfig(clientToken: string, rawConfig: string) {
   try {
-    localStorage.setItem(SDK_CONFIG_CACHE_KEY, rawConfig)
+    localStorage.setItem(sdkConfigCacheKey(clientToken), rawConfig)
   } catch {
     // Ignore: caching is an optimization, not a requirement.
   }
 }
 
-export function clearCachedSdkConfig() {
+export function clearCachedSdkConfig(clientToken: string) {
   try {
-    localStorage.removeItem(SDK_CONFIG_CACHE_KEY)
+    localStorage.removeItem(sdkConfigCacheKey(clientToken))
   } catch {
     // Ignore.
   }
@@ -105,7 +120,7 @@ export function parseSdkConfig(raw: string): RemoteSdkConfig | undefined {
  * as a resource or a network error.
  */
 export function buildSdkConfigEndpoint(initConfiguration: InitConfiguration, applicationId?: string): string {
-  const host = buildEndpointHost('rum', initConfiguration)
+  const host = initConfiguration.kubesenseRumEndpoint ?? INTAKE_SITE_PROD
   const parameters = [
     'ksource=browser',
     `kubesense-api-key=${encodeURIComponent(initConfiguration.clientToken)}`,
@@ -120,15 +135,15 @@ export function buildSdkConfigEndpoint(initConfiguration: InitConfiguration, app
 }
 
 /**
- * Fetch the document and refresh the cache for the *next* page load. Fire-and-forget: any
- * failure (offline, 404 because the collector has no config file, 401, timeout, malformed
- * body) leaves the existing cache untouched.
+ * Fetch the document and refresh the cache for the *next* page load. Fire-and-forget: a 404 —
+ * the collector has no configuration for this application — clears the cache, and any other
+ * failure (offline, 401, 5xx, timeout, malformed body) leaves it untouched.
  *
  * The response is validated before it overwrites the cache, so a half-written document on the
  * collector can never poison a client.
  */
 export function refreshSdkConfig(initConfiguration: InitConfiguration, applicationId?: string): Promise<void> {
-  if (typeof fetch !== 'function') {
+  if (!('fetch' in globalObject)) {
     return Promise.resolve()
   }
 
@@ -150,8 +165,15 @@ export function refreshSdkConfig(initConfiguration: InitConfiguration, applicati
     signal: createTimeoutSignal(SDK_CONFIG_FETCH_TIMEOUT),
   })
     .then((response) => {
+      if (response.status === 404) {
+        // The collector has no configuration for this application — it was removed, or never
+        // published. Forget the cached one, or the application would keep running on a document
+        // nobody can see or change any more.
+        clearCachedSdkConfig(initConfiguration.clientToken)
+        return undefined
+      }
       if (!response.ok) {
-        // 404 simply means "no configuration published"; keep whatever we already had.
+        // An auth or server problem says nothing about the configuration: keep the cached one.
         return undefined
       }
       return response.text()
@@ -164,7 +186,7 @@ export function refreshSdkConfig(initConfiguration: InitConfiguration, applicati
         display.warn('Remote SDK configuration is not a valid JSON object, ignoring it.')
         return
       }
-      setCachedSdkConfig(rawConfig)
+      setCachedSdkConfig(initConfiguration.clientToken, rawConfig)
     })
     .catch(() => {
       // Network failures are expected and must stay silent: the SDK keeps running on the
@@ -198,6 +220,33 @@ export function readSampleRate(source: { [key: string]: unknown } | undefined, k
   return typeof value === 'number' && isFinite(value) && value >= 0 && value <= 100 ? value : undefined
 }
 
+/**
+ * Reads a number the SDK only accepts within a fixed range. Out-of-range values are rejected rather
+ * than clamped: a dashboard that asks for something the SDK cannot honour should fall back to the
+ * local value, not to a silently different one.
+ */
+export function readNumberInRange(
+  source: { [key: string]: unknown } | undefined,
+  key: string,
+  min: number,
+  max: number
+): number | undefined {
+  const value = source?.[key]
+  return typeof value === 'number' && isFinite(value) && value >= min && value <= max ? value : undefined
+}
+
+/**
+ * Reads a list of non-empty strings, dropping unusable entries. Returns `undefined` for anything
+ * that is not an array, or when no entry survives, so the local value keeps applying.
+ */
+export function readStringList(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined
+  }
+  const strings = value.filter((item): item is string => typeof item === 'string' && item.length > 0)
+  return strings.length > 0 ? strings : undefined
+}
+
 export function readString(source: { [key: string]: unknown } | undefined, key: string): string | undefined {
   const value = source?.[key]
   return typeof value === 'string' && value.length > 0 ? value : undefined

package/src/domain/connectivity/connectivity.ts

@@ -1,37 +1,25 @@
-import { globalObject } from '../../tools/globalObject'
-
-export type NetworkInterface = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown'
-export type EffectiveType = 'slow-2g' | '2g' | '3g' | '4g'
-
-interface BrowserNavigator extends Navigator {
-  connection?: NetworkInformation
-}
-
-export interface NetworkInformation {
-  type?: NetworkInterface
-  effectiveType?: EffectiveType
-  rtt?: number
-  downlink?: number
-  saveData: boolean
-}
+import type { NetworkEffectiveType, NetworkInterface } from '@kubesense/kubesense-js-core/util'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
 
 export interface Connectivity {
   status: 'connected' | 'not_connected'
   interfaces?: NetworkInterface[]
-  effective_type?: EffectiveType
+  effective_type?: NetworkEffectiveType
   rtt?: number
   downlink?: number
   [key: string]: unknown
 }
 
 export function getConnectivity(): Connectivity {
-  const navigator = globalObject.navigator as BrowserNavigator
+  const { navigator } = globalObject
 
   return {
-    status: navigator.onLine ? 'connected' : 'not_connected',
-    interfaces: navigator.connection && navigator.connection.type ? [navigator.connection.type] : ['unknown'],
-    effective_type: navigator.connection?.effectiveType,
-    rtt: navigator.connection?.rtt,
-    downlink: navigator.connection?.downlink,
+    status: navigator?.onLine ? 'connected' : 'not_connected',
+    // Report 'unknown' rather than nothing when the browser does not expose a connection type, so
+    // the field is always present and dashboards do not have to special-case its absence.
+    interfaces: navigator?.connection?.type ? [navigator.connection.type] : ['unknown'],
+    effective_type: navigator?.connection?.effectiveType,
+    rtt: navigator?.connection?.rtt,
+    downlink: navigator?.connection?.downlink,
   }
 }

package/src/domain/console/consoleObservable.ts

@@ -1,14 +1,14 @@
+import { clocksNow } from '@kubesense/kubesense-js-core/time'
+import { ConsoleApiName, globalConsole } from '@kubesense/kubesense-js-core/util'
+import { callMonitored } from '@kubesense/kubesense-js-core/monitor'
 import { isError, computeRawError } from '../error/error'
-import { mergeObservables, Observable } from '../../tools/observable'
-import { ConsoleApiName, globalConsole } from '../../tools/display'
-import { callMonitored } from '../../tools/monitor'
+import { Observable, mergeObservables } from '../../tools/observable'
 import { sanitize } from '../../tools/serialisation/sanitize'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
 import type { RawError } from '../error/error.types'
 import { ErrorHandling, ErrorSource, NonErrorPrefix } from '../error/error.types'
 import { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'
 import { createHandlingStack, formatErrorMessage } from '../../tools/stackTrace/handlingStack'
-import { clocksNow } from '../../tools/utils/timeUtils'
 
 export type ConsoleLog = NonErrorConsoleLog | ErrorConsoleLog
 
@@ -51,6 +51,7 @@ export function resetConsoleObservable() {
 
 function createConsoleObservable(api: ConsoleApiName) {
   return new Observable<ConsoleLog>((observable) => {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     const originalConsoleApi = globalConsole[api]
 
     globalConsole[api] = (...params: unknown[]) => {
@@ -75,7 +76,10 @@ function buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack:
     const firstErrorParam = params.find(isError)
 
     const rawError = computeRawError({
-      originalError: firstErrorParam,
+      // `console.error` is commonly called without any Error instance. Falling back to the first
+      // parameter lets the error type be derived from what was actually logged (`String`,
+      // `Object`...) instead of nothing, and exposes it to `beforeSend` like the other sources do.
+      originalError: firstErrorParam ?? params[0],
       handlingStack,
       startClocks: clocksNow(),
       source: ErrorSource.CONSOLE,

package/src/domain/context/contextManager.ts

@@ -1,4 +1,4 @@
-import { deepClone } from '../../tools/mergeInto'
+import { deepClone } from '@kubesense/kubesense-js-core/util'
 import { sanitize } from '../../tools/serialisation/sanitize'
 import type { Context } from '../../tools/serialisation/context'
 import { Observable } from '../../tools/observable'
@@ -8,7 +8,10 @@ import { checkContext } from './contextUtils'
 export type ContextManager = ReturnType<typeof createContextManager>
 
 export interface PropertiesConfig {
-  [key: string]: { required?: boolean; type?: 'string' }
+  [key: string]: {
+    required?: boolean
+    type?: 'string'
+  }
 }
 
 function ensureProperties(context: Context, propertiesConfig: PropertiesConfig, name: string) {
@@ -17,6 +20,7 @@ function ensureProperties(context: Context, propertiesConfig: PropertiesConfig,
   for (const [key, { required, type }] of Object.entries(propertiesConfig)) {
     /**
      * Ensure specified properties are strings as defined here:
+     * https://docs.kubesense.ai/logs/log_configuration/attributes_naming_convention/#user-related-attributes
      */
 
     if (type === 'string' && !isDefined(newContext[key])) {

package/src/domain/context/contextUtils.ts

@@ -1,6 +1,6 @@
+import { getType } from '@kubesense/kubesense-js-core/util'
 import type { Context } from '../../tools/serialisation/context'
 import { display } from '../../tools/display'
-import { getType } from '../../tools/utils/typeUtils'
 
 /**
  * Simple check to ensure an object is a valid context

package/src/domain/context/defineContextMethod.ts

@@ -1,7 +1,7 @@
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
 import type { RawTelemetryUsage, RawTelemetryUsageFeature } from '../telemetry'
 import { addTelemetryUsage } from '../telemetry'
-import { monitor } from '../../tools/monitor'
-import type { BoundedBuffer } from '../../tools/boundedBuffer'
+import type { BufferedObservable } from '../../tools/observable'
 import type { ContextManager } from './contextManager'
 import type { ContextManagerMethod, CustomerContextKey } from './contextConstants'
 
@@ -22,10 +22,10 @@ export function defineContextMethod<MethodName extends ContextManagerMethod, Key
 export function bufferContextCalls<Key extends string, StartResult extends Record<Key, ContextManager>>(
   preStartContextManager: ContextManager,
   name: Key,
-  bufferApiCalls: BoundedBuffer<StartResult>
+  bufferApiCalls: BufferedObservable<(startResult: StartResult) => void>
 ) {
   preStartContextManager.changeObservable.subscribe(() => {
     const context = preStartContextManager.getContext()
-    bufferApiCalls.add((startResult) => startResult[name].setContext(context))
+    bufferApiCalls.notify((startResult) => startResult[name].setContext(context))
   })
 }

package/src/domain/context/storeContextManager.ts

@@ -1,8 +1,7 @@
+import { combine } from '@kubesense/kubesense-js-core/util'
 import { addEventListener, DOM_EVENT } from '../../browser/addEventListener'
 import type { Context } from '../../tools/serialisation/context'
-import type { Configuration } from '../configuration'
-import { combine } from '../../tools/mergeInto'
-import { isEmptyObject } from '../../tools/utils/objectUtils'
+import { isEmptyObject, tryJsonParse } from '../../tools/utils/objectUtils'
 import type { ContextManager } from './contextManager'
 import type { CustomerDataType } from './contextConstants'
 
@@ -11,15 +10,19 @@ const CONTEXT_STORE_KEY_PREFIX = '_kubesense_c'
 const storageListeners: Array<{ stop: () => void }> = []
 
 export function storeContextManager(
-  configuration: Configuration,
   contextManager: ContextManager,
   productKey: string,
   customerDataType: CustomerDataType
 ) {
+  // window and localStorage are not available in Web Workers or Node.js environments
+  if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
+    return
+  }
+
   const storageKey = buildStorageKey(productKey, customerDataType)
 
   storageListeners.push(
-    addEventListener(configuration, window, DOM_EVENT.STORAGE, ({ key }) => {
+    addEventListener(window, DOM_EVENT.STORAGE, ({ key }) => {
       if (storageKey === key) {
         synchronizeWithStorage()
       }
@@ -42,7 +45,7 @@ export function storeContextManager(
 
   function getFromStorage() {
     const rawContext = localStorage.getItem(storageKey)
-    return rawContext ? (JSON.parse(rawContext) as Context) : {}
+    return rawContext ? (tryJsonParse<Context>(rawContext) ?? {}) : {}
   }
 }
 

package/src/domain/contexts/accountContext.ts

@@ -1,8 +1,8 @@
+import type { Hook } from '@kubesense/kubesense-js-core/assembly'
+import { SKIPPED } from '@kubesense/kubesense-js-core/assembly'
 import type { Configuration } from '../configuration'
 import { CustomerDataType } from '../context/contextConstants'
 import { storeContextManager } from '../context/storeContextManager'
-import { HookNames, SKIPPED } from '../../tools/abstractHooks'
-import type { AbstractHooks } from '../../tools/abstractHooks'
 import { isEmptyObject } from '../../tools/utils/objectUtils'
 import { createContextManager } from '../context/contextManager'
 
@@ -15,14 +15,14 @@ export interface Account {
   [key: string]: unknown
 }
 
-export function startAccountContext(hooks: AbstractHooks, configuration: Configuration, productKey: string) {
+export function startAccountContext(assembleHook: Hook<any, any>, configuration: Configuration, productKey: string) {
   const accountContextManager = buildAccountContextManager()
 
   if (configuration.storeContextsAcrossPages) {
-    storeContextManager(configuration, accountContextManager, productKey, CustomerDataType.Account)
+    storeContextManager(accountContextManager, productKey, CustomerDataType.Account)
   }
 
-  hooks.register(HookNames.Assemble, () => {
+  assembleHook.register(() => {
     const account = accountContextManager.getContext() as Account
 
     if (isEmptyObject(account) || !account.id) {

package/src/domain/contexts/globalContext.ts

@@ -1,12 +1,11 @@
-import type { AbstractHooks } from '../../tools/abstractHooks'
+import type { Hook } from '@kubesense/kubesense-js-core/assembly'
 import { CustomerDataType } from '../context/contextConstants'
 import { storeContextManager } from '../context/storeContextManager'
-import { HookNames } from '../../tools/abstractHooks'
 import { createContextManager } from '../context/contextManager'
 import type { Configuration } from '../configuration'
 
 export function startGlobalContext(
-  hooks: AbstractHooks,
+  assembleHook: Hook<any, any>,
   configuration: Configuration,
   productKey: string,
   useContextNamespace: boolean
@@ -14,10 +13,10 @@ export function startGlobalContext(
   const globalContextManager = buildGlobalContextManager()
 
   if (configuration.storeContextsAcrossPages) {
-    storeContextManager(configuration, globalContextManager, productKey, CustomerDataType.GlobalContext)
+    storeContextManager(globalContextManager, productKey, CustomerDataType.GlobalContext)
   }
 
-  hooks.register(HookNames.Assemble, () => {
+  assembleHook.register(() => {
     const context = globalContextManager.getContext()
     return useContextNamespace ? { context } : context
   })

package/src/domain/contexts/tabContext.ts

@@ -0,0 +1,43 @@
+import type { Hook } from '@kubesense/kubesense-js-core/assembly'
+import { generateUUID } from '../../tools/utils/stringUtils'
+
+export const TAB_ID_STORAGE_KEY = '_kubesense_tab_id'
+
+let cachedTabId: string | undefined
+
+// Exported for test cleanup only — allows specs to reset the in-memory cache between tests.
+export function resetCachedTabId(): void {
+  cachedTabId = undefined
+}
+
+export function startTabContext(assembleHook: Hook<any, any>) {
+  const tabId = retrieveOrCreateTabId()
+
+  assembleHook.register(() => ({
+    tab: {
+      id: tabId,
+    },
+  }))
+}
+
+function retrieveOrCreateTabId(): string {
+  if (!cachedTabId) {
+    cachedTabId = getOrCreateIdInSessionStorage() ?? generateUUID()
+  }
+  return cachedTabId
+}
+
+function getOrCreateIdInSessionStorage(): string | undefined {
+  try {
+    const existingId = sessionStorage.getItem(TAB_ID_STORAGE_KEY)
+    if (existingId) {
+      return existingId
+    }
+    const newId = generateUUID()
+    sessionStorage.setItem(TAB_ID_STORAGE_KEY, newId)
+    return newId
+  } catch {
+    // sessionStorage unavailable (e.g. Web Worker, sandboxed iframe, quota exceeded)
+    return undefined
+  }
+}

package/src/domain/contexts/telemetrySessionContext.ts

@@ -0,0 +1,26 @@
+import type { Hook } from '@kubesense/kubesense-js-core/assembly'
+import { SKIPPED } from '@kubesense/kubesense-js-core/assembly'
+import type { SessionManager } from '../session/sessionManager'
+import type { Context } from '../../tools/serialisation/context'
+
+export function startTelemetrySessionContext(
+  assembleTelemetryHook: Hook<any, any>,
+  sessionManager: SessionManager,
+  extraContext?: Context
+) {
+  assembleTelemetryHook.register(({ startTime }) => {
+    const session = sessionManager.findTrackedSession(startTime)
+
+    if (!session) {
+      return SKIPPED
+    }
+
+    return {
+      session: {
+        id: session.id,
+      },
+      anonymous_id: session.anonymousId,
+      ...extraContext,
+    }
+  })
+}

package/src/domain/contexts/userContext.ts

@@ -1,15 +1,16 @@
-import type { AbstractHooks } from '../../tools/abstractHooks'
+import type { RelativeTime } from '@kubesense/kubesense-js-core/time'
+import { clocksOrigin, relativeNow } from '@kubesense/kubesense-js-core/time'
+import type { Hook } from '@kubesense/kubesense-js-core/assembly'
+import { SKIPPED } from '@kubesense/kubesense-js-core/assembly'
+import { deepClone } from '@kubesense/kubesense-js-core/util'
 import { CustomerDataType } from '../context/contextConstants'
 import { storeContextManager } from '../context/storeContextManager'
-import { HookNames, SKIPPED } from '../../tools/abstractHooks'
 import { createContextManager } from '../context/contextManager'
 import type { Configuration } from '../configuration'
 import { isEmptyObject } from '../../tools/utils/objectUtils'
-import type { RelativeTime } from '../../tools/utils/timeUtils'
-import { clocksOrigin, relativeNow } from '../../tools/utils/timeUtils'
-import { createValueHistory } from '../../tools/valueHistory'
-import { deepClone } from '../../tools/mergeInto'
+import { jsonStringify } from '../../tools/serialisation/jsonStringify'
 import type { Context } from '../../tools/serialisation/context'
+import { createValueHistory } from '../../tools/valueHistory'
 import { SESSION_TIME_OUT_DELAY } from '../session/sessionConstants'
 
 export interface User {
@@ -22,6 +23,14 @@ export interface User {
 
 const SESSION_OWNER_STORAGE_PREFIX = '_kubesense_session_user'
 
+/**
+ * The user id is sanitized to a string by the context manager, but `getContext()` is typed as
+ * `Context`, so non-string values are normalized here rather than stringified blindly.
+ */
+function toUserIdString(userId: unknown): string | undefined {
+  return typeof userId === 'string' ? userId : userId === undefined ? undefined : jsonStringify(userId)
+}
+
 function getSessionOwnerKey(productKey: string) {
   return `${SESSION_OWNER_STORAGE_PREFIX}_${productKey}`
 }
@@ -48,7 +57,7 @@ function writeSessionOwnerUserId(productKey: string, userId: string | undefined)
 }
 
 export function startUserContext(
-  hooks: AbstractHooks,
+  hook: Hook<{ eventType?: string; startTime: RelativeTime }, { usr?: User }>,
   configuration: Configuration,
   sessionManager: {
     findTrackedSession: (startTime?: RelativeTime) => { anonymousId?: string } | undefined
@@ -59,7 +68,7 @@ export function startUserContext(
   const userContextManager = buildUserContextManager()
 
   if (configuration.storeContextsAcrossPages) {
-    storeContextManager(configuration, userContextManager, productKey, CustomerDataType.User)
+    storeContextManager(userContextManager, productKey, CustomerDataType.User)
   }
 
   // Expire the session when the user identity changes so that the new user
@@ -72,7 +81,7 @@ export function startUserContext(
     // expire on mismatch before any events get assembled with a stale session id.
     const initialUserId = userContextManager.getContext().id
     const sessionOwnerUserId = readSessionOwnerUserId(productKey)
-    const initialUserIdString = initialUserId !== undefined ? String(initialUserId) : undefined
+    const initialUserIdString = toUserIdString(initialUserId)
 
     if (
       sessionOwnerUserId !== undefined &&
@@ -88,7 +97,7 @@ export function startUserContext(
     let previousUserId: string | undefined = initialUserIdString ?? sessionOwnerUserId
     userContextManager.changeObservable.subscribe(() => {
       const rawCurrentUserId = userContextManager.getContext().id
-      const currentUserId = rawCurrentUserId !== undefined ? String(rawCurrentUserId) : undefined
+      const currentUserId = toUserIdString(rawCurrentUserId)
       if (currentUserId !== previousUserId) {
         sessionManager.expire!()
         writeSessionOwnerUserId(productKey, currentUserId)
@@ -112,12 +121,12 @@ export function startUserContext(
     userContextHistory.add(userContextManager.getContext(), now)
   })
 
-  hooks.register(HookNames.Assemble, ({ eventType, startTime }) => {
+  hook.register(({ eventType, startTime }) => {
     const historicalUser = userContextHistory.find(startTime)
     const user = historicalUser ? deepClone(historicalUser) : userContextManager.getContext()
     const session = sessionManager.findTrackedSession(startTime)
 
-    if (session && session.anonymousId && !user.anonymous_id && !!configuration.trackAnonymousUser) {
+    if (session?.anonymousId && !user.anonymous_id && !!configuration.trackAnonymousUser) {
       user.anonymous_id = session.anonymousId
     }
 
@@ -131,10 +140,6 @@ export function startUserContext(
     }
   })
 
-  hooks.register(HookNames.AssembleTelemetry, ({ startTime }) => ({
-    anonymous_id: sessionManager.findTrackedSession(startTime)?.anonymousId,
-  }))
-
   return userContextManager
 }