@observtech/rum 0.1.32 → 0.1.34

package/dist/index.js

@@ -1,14 +1,15 @@
-import { ATTR_EXCEPTION_MESSAGE, ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, ATTR_EXCEPTION_TYPE, ATTR_EXCEPTION_STACKTRACE } from '@opentelemetry/semantic-conventions';
+import { registerInstrumentations } from './chunk-P6VK4P6W.js';
+import { SeverityNumber } from '@opentelemetry/api-logs';
 import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
 import { LoggerProvider, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
 import { resourceFromAttributes } from '@opentelemetry/resources';
+import { ATTR_EXCEPTION_MESSAGE, ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, ATTR_EXCEPTION_TYPE, ATTR_EXCEPTION_STACKTRACE } from '@opentelemetry/semantic-conventions';
 import { ATTR_SESSION_ID } from '@opentelemetry/semantic-conventions/incubating';
-import { trace, metrics } from '@opentelemetry/api';
+import '@opentelemetry/api';
 import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
 import { PeriodicExportingMetricReader, MeterProvider } from '@opentelemetry/sdk-metrics';
 import { onLCP, onINP, onFCP, onTTFB, onCLS } from 'web-vitals';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { logs } from '@opentelemetry/api-logs';
 import { DocumentLoadInstrumentation } from '@opentelemetry/instrumentation-document-load';
 import { FetchInstrumentation } from '@opentelemetry/instrumentation-fetch';
 import { XMLHttpRequestInstrumentation } from '@opentelemetry/instrumentation-xml-http-request';
@@ -63,6 +64,57 @@ function installBaggagePropagation(getId, backendUrls, ignoreUrls = []) {
     window.fetch = originalFetch;
   };
 }
+
+// src/consent.ts
+var DEFAULT_KEY = "observ.consent";
+var DEFAULT_GRANTED = ["granted", "true", "1", "yes", "all"];
+function readCookie(key) {
+  if (typeof document === "undefined" || !document.cookie) return void 0;
+  for (const part of document.cookie.split(";")) {
+    const idx = part.indexOf("=");
+    if (idx === -1) continue;
+    if (part.slice(0, idx).trim() === key) {
+      try {
+        return decodeURIComponent(part.slice(idx + 1).trim());
+      } catch {
+        return part.slice(idx + 1).trim();
+      }
+    }
+  }
+  return void 0;
+}
+function readStorage(key) {
+  try {
+    return globalThis.localStorage?.getItem(key) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function consentKey(opts) {
+  return opts.consentKey || DEFAULT_KEY;
+}
+function grantedValue(opts) {
+  return opts.consentGrantedValues?.[0] ?? "granted";
+}
+function hasAnalyticsConsent(opts) {
+  if (!opts.requireConsent) return true;
+  const key = consentKey(opts);
+  const granted = (opts.consentGrantedValues ?? DEFAULT_GRANTED).map((v) => v.toLowerCase());
+  const value = readCookie(key) ?? readStorage(key);
+  return value != null && granted.includes(value.toLowerCase());
+}
+function writeConsent(opts) {
+  try {
+    globalThis.localStorage?.setItem(consentKey(opts), grantedValue(opts));
+  } catch {
+  }
+}
+function clearConsent(opts) {
+  try {
+    globalThis.localStorage?.removeItem(consentKey(opts));
+  } catch {
+  }
+}
 function buildResource(options) {
   const attrs = {
     "telemetry.sdk.language": "webjs"
@@ -81,11 +133,8 @@ function buildResource(options) {
 }
 var SESSION_ID_ATTRIBUTE = ATTR_SESSION_ID;
 
-// src/session.ts
-var SESSION_STORAGE_KEY = "observ.rum.session";
-var SESSION_INACTIVITY_TIMEOUT_MS = 30 * 60 * 1e3;
-var current = null;
-function generateSessionId() {
+// src/random-id.ts
+function generateUuid() {
   const c = globalThis.crypto;
   if (c && typeof c.randomUUID === "function") {
     try {
@@ -106,16 +155,58 @@ function generateSessionId() {
     return v.toString(16);
   });
 }
+
+// src/session.ts
+var SESSION_STORAGE_KEY = "observ.rum.session";
+var SESSION_INACTIVITY_TIMEOUT_MS = 30 * 60 * 1e3;
+var SESSION_MAX_DURATION_MS = 4 * 60 * 60 * 1e3;
+var current = null;
+var inactivityTimeoutMs = SESSION_INACTIVITY_TIMEOUT_MS;
+var maxDurationMs = SESSION_MAX_DURATION_MS;
+var storageMode = "session";
+var listeners = /* @__PURE__ */ new Set();
+function configureSession(opts) {
+  if (typeof opts.inactivityTimeoutMs === "number" && opts.inactivityTimeoutMs > 0) {
+    inactivityTimeoutMs = opts.inactivityTimeoutMs;
+  }
+  if (typeof opts.maxDurationMs === "number" && opts.maxDurationMs > 0) {
+    maxDurationMs = opts.maxDurationMs;
+  }
+  if (typeof opts.crossTab === "boolean") {
+    storageMode = opts.crossTab ? "local" : "session";
+  }
+}
+function addSessionListener(fn) {
+  listeners.add(fn);
+  return () => {
+    listeners.delete(fn);
+  };
+}
+function notify(event) {
+  for (const fn of listeners) {
+    try {
+      fn(event);
+    } catch {
+    }
+  }
+}
+function backend() {
+  try {
+    return storageMode === "local" ? globalThis.localStorage : globalThis.sessionStorage;
+  } catch {
+    return void 0;
+  }
+}
 function safeRead() {
   try {
-    return globalThis.sessionStorage?.getItem(SESSION_STORAGE_KEY) ?? null;
+    return backend()?.getItem(SESSION_STORAGE_KEY) ?? null;
   } catch {
     return null;
   }
 }
 function safeWrite(value) {
   try {
-    globalThis.sessionStorage?.setItem(SESSION_STORAGE_KEY, value);
+    backend()?.setItem(SESSION_STORAGE_KEY, value);
   } catch {
   }
 }
@@ -139,22 +230,110 @@ function save(session) {
   current = session;
   safeWrite(JSON.stringify(session));
 }
+function isExpired(session, now) {
+  if (!session) return true;
+  const inactiveFor = Math.max(0, now - session.lastActivityAt);
+  const ageFor = Math.max(0, now - session.startedAt);
+  return inactiveFor > inactivityTimeoutMs || ageFor > maxDurationMs;
+}
 function ensureSession(now = Date.now()) {
   const existing = load();
-  if (existing) {
-    const elapsed = Math.max(0, now - existing.lastActivityAt);
-    if (elapsed <= SESSION_INACTIVITY_TIMEOUT_MS) {
-      save({ ...existing, lastActivityAt: now });
-      return existing.id;
-    }
+  if (existing && !isExpired(existing, now)) {
+    save({ ...existing, lastActivityAt: now });
+    return existing.id;
+  }
+  if (existing && existing.endedAt == null) {
+    notify({ type: "end", id: existing.id, durationMs: Math.max(0, now - existing.startedAt) });
   }
-  const fresh = { id: generateSessionId(), startedAt: now, lastActivityAt: now };
+  const fresh = {
+    id: generateUuid(),
+    startedAt: now,
+    lastActivityAt: now,
+    ...existing ? { previousId: existing.id } : {}
+  };
   save(fresh);
+  notify({ type: "start", id: fresh.id, ...existing ? { previousId: existing.id } : {} });
   return fresh.id;
 }
 function getSessionId(now = Date.now()) {
   return ensureSession(now);
 }
+function touchSession(now = Date.now()) {
+  ensureSession(now);
+}
+function endSessionIfExpired(now = Date.now()) {
+  const session = load();
+  if (!session || session.endedAt != null || !isExpired(session, now)) return;
+  save({ ...session, endedAt: now });
+  notify({ type: "end", id: session.id, durationMs: Math.max(0, now - session.startedAt) });
+}
+function adoptStoredSession() {
+  const raw = safeRead();
+  if (raw === null) return;
+  try {
+    const parsed = JSON.parse(raw);
+    if (isPersistedSession(parsed)) current = parsed;
+  } catch {
+  }
+}
+
+// src/user.ts
+var ATTR_ENDUSER_ID = "enduser.id";
+var ATTR_ENDUSER_ROLE = "enduser.role";
+var ATTR_ENDUSER_NAME = "enduser.name";
+var ATTR_ENDUSER_PSEUDO_ID = "enduser.pseudo.id";
+var PSEUDO_USER_STORAGE_KEY = "observ.rum.pseudo";
+var currentUser = null;
+var pseudoEnabled = true;
+var pseudoId;
+function configureUser(opts) {
+  if (typeof opts.disablePseudoUser === "boolean") {
+    pseudoEnabled = !opts.disablePseudoUser;
+  }
+}
+function setUser(user) {
+  currentUser = user;
+}
+function clearUser() {
+  currentUser = null;
+}
+function getPseudoUserId() {
+  if (!pseudoEnabled) return void 0;
+  if (pseudoId) return pseudoId;
+  try {
+    const existing = globalThis.localStorage?.getItem(PSEUDO_USER_STORAGE_KEY);
+    if (existing) {
+      pseudoId = existing;
+      return pseudoId;
+    }
+  } catch {
+  }
+  pseudoId = generateUuid();
+  try {
+    globalThis.localStorage?.setItem(PSEUDO_USER_STORAGE_KEY, pseudoId);
+  } catch {
+  }
+  return pseudoId;
+}
+function userAttributes() {
+  const attrs = {};
+  const pseudo = getPseudoUserId();
+  if (pseudo) attrs[ATTR_ENDUSER_PSEUDO_ID] = pseudo;
+  if (currentUser) {
+    attrs[ATTR_ENDUSER_ID] = String(currentUser.id);
+    if (currentUser.role) attrs[ATTR_ENDUSER_ROLE] = currentUser.role;
+    if (currentUser.name) attrs[ATTR_ENDUSER_NAME] = currentUser.name;
+  }
+  return attrs;
+}
+function applyUserAttributes(setAttribute) {
+  try {
+    for (const [key, value] of Object.entries(userAttributes())) {
+      setAttribute(key, value);
+    }
+  } catch {
+  }
+}
 
 // src/otel-logs.ts
 function buildLogsUrl(endpoint) {
@@ -200,12 +379,17 @@ function currentSessionId() {
   }
   return cachedSessionId;
 }
+function resetSessionIdCache() {
+  cachedSessionId = "";
+  cachedSessionIdAt = 0;
+}
 function emitSessionEvent(logger, eventName, attrs = {}) {
   try {
     logger.emit({
       attributes: {
         "event.name": eventName,
         [SESSION_ID_ATTRIBUTE]: currentSessionId(),
+        ...userAttributes(),
         ...attrs
       }
     });
@@ -213,6 +397,20 @@ function emitSessionEvent(logger, eventName, attrs = {}) {
     console.warn("[observ] semantic event emit failed", err);
   }
 }
+function emitLogRecord(logger, severityNumber, severityText, body) {
+  try {
+    logger.emit({
+      severityNumber,
+      severityText,
+      body,
+      attributes: {
+        [SESSION_ID_ATTRIBUTE]: currentSessionId(),
+        ...userAttributes()
+      }
+    });
+  } catch {
+  }
+}
 async function shutdownOtelLogs() {
   const p = provider;
   provider = null;
@@ -220,7 +418,84 @@ async function shutdownOtelLogs() {
   await p?.shutdown();
 }
 
-// src/js-errors.ts
+// src/console-forward.ts
+var LEVELS = {
+  debug: { number: SeverityNumber.DEBUG, text: "DEBUG" },
+  log: { number: SeverityNumber.INFO, text: "INFO" },
+  info: { number: SeverityNumber.INFO, text: "INFO" },
+  warn: { number: SeverityNumber.WARN, text: "WARN" },
+  error: { number: SeverityNumber.ERROR, text: "ERROR" }
+};
+var ALL_LEVELS = Object.keys(LEVELS);
+var MAX_BODY = 4096;
+var NOOP = { stop: () => {
+} };
+var active = null;
+function resolveLevels(forwardConsole) {
+  if (forwardConsole === true) return ALL_LEVELS;
+  if (Array.isArray(forwardConsole)) return forwardConsole.filter((l) => l in LEVELS);
+  return [];
+}
+function formatArg(arg) {
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  if (typeof arg === "object" && arg !== null) {
+    try {
+      return JSON.stringify(arg) ?? String(arg);
+    } catch {
+      return String(arg);
+    }
+  }
+  return String(arg);
+}
+function formatBody(args) {
+  const body = args.map(formatArg).join(" ");
+  return body.length > MAX_BODY ? body.slice(0, MAX_BODY) : body;
+}
+function startConsoleForward(options) {
+  if (active) return active;
+  const levels = resolveLevels(options.forwardConsole);
+  if (levels.length === 0 || typeof console === "undefined") return NOOP;
+  let logger;
+  try {
+    logger = setupOtelLogs(options);
+  } catch {
+    return NOOP;
+  }
+  let emitting = false;
+  const originals = /* @__PURE__ */ new Map();
+  for (const level of levels) {
+    const original = console[level];
+    if (typeof original !== "function") continue;
+    originals.set(level, original);
+    const { number, text } = LEVELS[level];
+    console[level] = (...args) => {
+      if (!emitting) {
+        emitting = true;
+        try {
+          emitLogRecord(logger, number, text, formatBody(args));
+        } catch {
+        } finally {
+          emitting = false;
+        }
+      }
+      original.apply(console, args);
+    };
+  }
+  let stopped = false;
+  const handle = {
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      active = null;
+      for (const [level, original] of originals) {
+        console[level] = original;
+      }
+      originals.clear();
+    }
+  };
+  active = handle;
+  return handle;
+}
 var MAX_JS_ERRORS = 50;
 var RATE_WINDOW_MS = 6e4;
 var MAX_MESSAGE = 1024;
@@ -236,21 +511,21 @@ function reasonToMessage(reason) {
   }
   return String(reason);
 }
-var NOOP = { stop: () => {
+var NOOP2 = { stop: () => {
 } };
-var active = null;
+var active2 = null;
 function truncate(s, max) {
   return s.length > max ? s.slice(0, max) : s;
 }
 function startJsErrorCapture(options) {
-  if (active) return active;
-  if (typeof window === "undefined") return NOOP;
+  if (active2) return active2;
+  if (typeof window === "undefined") return NOOP2;
   let logger;
   try {
     logger = setupOtelLogs(options);
   } catch (err) {
     console.warn("[observ] js-errors: logs setup failed", err);
-    return NOOP;
+    return NOOP2;
   }
   let windowStart = 0;
   let inWindow = 0;
@@ -293,10 +568,10 @@ function startJsErrorCapture(options) {
     stop() {
       window.removeEventListener("error", onError);
       window.removeEventListener("unhandledrejection", onRejection);
-      active = null;
+      active2 = null;
     }
   };
-  active = handle;
+  active2 = handle;
   return handle;
 }
 var METRIC_EXPORT_INTERVAL_MS = 3e4;
@@ -378,40 +653,6 @@ async function shutdownOtelMetrics() {
   provider2 = null;
   await p?.shutdown();
 }
-
-// node_modules/@opentelemetry/instrumentation/build/esm/autoLoaderUtils.js
-function enableInstrumentations(instrumentations, tracerProvider, meterProvider, loggerProvider) {
-  for (let i = 0, j = instrumentations.length; i < j; i++) {
-    const instrumentation = instrumentations[i];
-    if (tracerProvider) {
-      instrumentation.setTracerProvider(tracerProvider);
-    }
-    if (meterProvider) {
-      instrumentation.setMeterProvider(meterProvider);
-    }
-    if (loggerProvider && instrumentation.setLoggerProvider) {
-      instrumentation.setLoggerProvider(loggerProvider);
-    }
-    if (!instrumentation.getConfig().enabled) {
-      instrumentation.enable();
-    }
-  }
-}
-function disableInstrumentations(instrumentations) {
-  instrumentations.forEach((instrumentation) => instrumentation.disable());
-}
-
-// node_modules/@opentelemetry/instrumentation/build/esm/autoLoader.js
-function registerInstrumentations(options) {
-  const tracerProvider = options.tracerProvider || trace.getTracerProvider();
-  const meterProvider = options.meterProvider || metrics.getMeterProvider();
-  const loggerProvider = options.loggerProvider || logs.getLoggerProvider();
-  const instrumentations = options.instrumentations?.flat() ?? [];
-  enableInstrumentations(instrumentations, tracerProvider, meterProvider, loggerProvider);
-  return () => {
-    disableInstrumentations(instrumentations);
-  };
-}
 function buildSampler(options) {
   const rate = options.sampleRate;
   if (typeof rate === "number" && Number.isFinite(rate) && rate >= 0 && rate < 1) {
@@ -450,9 +691,37 @@ var SessionAttributeSpanProcessor = class {
     return Promise.resolve();
   }
 };
+var UserAttributeSpanProcessor = class {
+  onStart(span) {
+    applyUserAttributes((key, value) => span.setAttribute(key, value));
+  }
+  onEnd(_span) {
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+};
 var provider3 = null;
-var disableInstrumentations2 = null;
+var disableInstrumentations = null;
 var activeConfig = null;
+var userInteractionReady = null;
+function buildBaseInstrumentations(options, ignoreUrls) {
+  return [
+    // Page-load timing: documentLoad / documentFetch / resourceFetch spans.
+    new DocumentLoadInstrumentation(),
+    new FetchInstrumentation({
+      propagateTraceHeaderCorsUrls: options.propagateTraceHeaderCorsUrls,
+      ignoreUrls
+    }),
+    new XMLHttpRequestInstrumentation({
+      propagateTraceHeaderCorsUrls: options.propagateTraceHeaderCorsUrls,
+      ignoreUrls
+    })
+  ];
+}
 function setupOtelRum(options) {
   if (provider3) {
     if (activeConfig && (activeConfig.endpoint !== options.endpoint || activeConfig.key !== options.key)) {
@@ -476,28 +745,38 @@ function setupOtelRum(options) {
   const p = new WebTracerProvider({
     resource: buildResource(options),
     sampler: buildSampler(options),
-    spanProcessors: [new SessionAttributeSpanProcessor(), new BatchSpanProcessor(exporter)]
+    spanProcessors: [
+      new SessionAttributeSpanProcessor(),
+      new UserAttributeSpanProcessor(),
+      new BatchSpanProcessor(exporter)
+    ]
   });
+  const base = buildBaseInstrumentations(options, ignoreUrls);
+  if (options.userInteraction) {
+    provider3 = p;
+    activeConfig = { endpoint: options.endpoint, key: options.key };
+    userInteractionReady = import('./user-interaction-HZJLQRUN.js').then(({ setupUserInteraction }) => {
+      if (provider3 !== p) return;
+      disableInstrumentations = setupUserInteraction(p, base);
+    }).catch((err) => {
+      console.warn("[observ] user-interaction setup failed; tracing degraded.", err);
+      if (provider3 === p) {
+        provider3 = null;
+        activeConfig = null;
+        void p.shutdown();
+      }
+    });
+    return;
+  }
   try {
     p.register();
-    disableInstrumentations2 = registerInstrumentations({
+    disableInstrumentations = registerInstrumentations({
       tracerProvider: p,
-      instrumentations: [
-        // Page-load timing: documentLoad / documentFetch / resourceFetch spans.
-        new DocumentLoadInstrumentation(),
-        new FetchInstrumentation({
-          propagateTraceHeaderCorsUrls: options.propagateTraceHeaderCorsUrls,
-          ignoreUrls
-        }),
-        new XMLHttpRequestInstrumentation({
-          propagateTraceHeaderCorsUrls: options.propagateTraceHeaderCorsUrls,
-          ignoreUrls
-        })
-      ]
+      instrumentations: base
     });
   } catch (err) {
-    disableInstrumentations2?.();
-    disableInstrumentations2 = null;
+    disableInstrumentations?.();
+    disableInstrumentations = null;
     void p.shutdown();
     throw err;
   }
@@ -505,17 +784,147 @@ function setupOtelRum(options) {
   activeConfig = { endpoint: options.endpoint, key: options.key };
 }
 async function shutdownOtelRum() {
+  const pending = userInteractionReady;
+  userInteractionReady = null;
+  if (pending) {
+    try {
+      await pending;
+    } catch {
+    }
+  }
   const p = provider3;
   try {
-    disableInstrumentations2?.();
+    disableInstrumentations?.();
   } finally {
-    disableInstrumentations2 = null;
+    disableInstrumentations = null;
     provider3 = null;
     activeConfig = null;
     await p?.shutdown();
   }
 }
 
+// src/history-nav.ts
+var subscribers = /* @__PURE__ */ new Set();
+var patched = false;
+var originalPush = null;
+var originalReplace = null;
+var popStateHandler = null;
+function notify2(type) {
+  for (const fn of subscribers) {
+    try {
+      fn({ type });
+    } catch {
+    }
+  }
+}
+function patch() {
+  if (patched || typeof window === "undefined" || typeof history === "undefined") return;
+  try {
+    originalPush = history.pushState;
+    originalReplace = history.replaceState;
+    history.pushState = function(...args) {
+      originalPush?.apply(this, args);
+      notify2("pushState");
+    };
+    history.replaceState = function(...args) {
+      originalReplace?.apply(this, args);
+      notify2("replaceState");
+    };
+  } catch {
+    if (originalPush) history.pushState = originalPush;
+    if (originalReplace) history.replaceState = originalReplace;
+    originalPush = null;
+    originalReplace = null;
+  }
+  popStateHandler = () => notify2("popstate");
+  window.addEventListener("popstate", popStateHandler);
+  patched = true;
+}
+function unpatch() {
+  if (!patched) return;
+  try {
+    if (originalPush) history.pushState = originalPush;
+    if (originalReplace) history.replaceState = originalReplace;
+    if (popStateHandler) window.removeEventListener("popstate", popStateHandler);
+  } catch {
+  }
+  originalPush = null;
+  originalReplace = null;
+  popStateHandler = null;
+  patched = false;
+}
+function onHistoryNavigation(listener) {
+  if (typeof window === "undefined") return () => {
+  };
+  subscribers.add(listener);
+  patch();
+  return () => {
+    subscribers.delete(listener);
+    if (subscribers.size === 0) unpatch();
+  };
+}
+
+// src/page-views.ts
+var PAGE_VIEW_EVENT = "app.page_view";
+var NOOP3 = { stop: () => {
+} };
+var active3 = null;
+function sanitizePath(path) {
+  return (path.split("?")[0] ?? path).split("#")[0] ?? "";
+}
+function nowMs() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function startPageViews(options) {
+  if (active3) return active3;
+  if (typeof window === "undefined" || typeof document === "undefined") return NOOP3;
+  let logger;
+  try {
+    logger = setupOtelLogs(options);
+  } catch {
+    return NOOP3;
+  }
+  let currentPath = sanitizePath(typeof location !== "undefined" ? location.pathname : "/");
+  let enteredAt = nowMs();
+  try {
+    const loadAttrs = {
+      "url.path": currentPath,
+      "app.page_view.navigation_type": "load"
+    };
+    if (document.referrer) loadAttrs["app.page_view.referrer"] = document.referrer;
+    emitSessionEvent(logger, PAGE_VIEW_EVENT, loadAttrs);
+  } catch {
+  }
+  const unsubscribe = onHistoryNavigation(() => {
+    try {
+      const toPath = sanitizePath(typeof location !== "undefined" ? location.pathname : currentPath);
+      touchSession();
+      if (toPath === currentPath) return;
+      const now = nowMs();
+      emitSessionEvent(logger, PAGE_VIEW_EVENT, {
+        "url.path": toPath,
+        "app.page_view.referrer_path": currentPath,
+        "app.page_view.time_on_previous_ms": String(Math.round(now - enteredAt)),
+        "app.page_view.navigation_type": "spa"
+      });
+      currentPath = toPath;
+      enteredAt = now;
+    } catch {
+    }
+  });
+  let stopped = false;
+  const handle = {
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      active3 = null;
+      unsubscribe();
+    }
+  };
+  active3 = handle;
+  return handle;
+}
+
 // src/privacy.ts
 var DEFAULT_MASK_TEXT_CLASS = "observ-mask";
 var DEFAULT_BLOCK_CLASS = "observ-block";
@@ -704,22 +1113,22 @@ function elementText(el) {
 var RAGE_CLICK_WINDOW_MS = 1e3;
 var RAGE_CLICK_THRESHOLD = 3;
 var MAX_TRACKED_SELECTORS = 100;
-var active2 = null;
-var NOOP2 = { stop: () => Promise.resolve() };
+var active4 = null;
+var NOOP4 = { stop: () => Promise.resolve() };
 function toElement(target) {
   if (target instanceof Element) return target;
   const node = target;
   return node && node.parentElement ? node.parentElement : null;
 }
 function startSemanticEvents(options) {
-  if (active2) return active2;
-  if (typeof document === "undefined" || typeof window === "undefined") return NOOP2;
+  if (active4) return active4;
+  if (typeof document === "undefined" || typeof window === "undefined") return NOOP4;
   let logger;
   try {
     logger = setupOtelLogs(options);
   } catch (err) {
     console.warn("[observ] semantic events: logs setup failed", err);
-    return NOOP2;
+    return NOOP4;
   }
   const clickTimes = /* @__PURE__ */ new Map();
   const onClick = (event) => {
@@ -744,45 +1153,124 @@ function startSemanticEvents(options) {
     } catch {
     }
   };
-  const emitNavigate = () => {
+  document.addEventListener("click", onClick, { capture: true });
+  const unsubscribeNav = onHistoryNavigation(() => {
     emitSessionEvent(logger, "observ.session.navigate", { url: location.href });
+  });
+  let stopped = false;
+  const handle = {
+    async stop() {
+      if (stopped) return;
+      stopped = true;
+      active4 = null;
+      document.removeEventListener("click", onClick, { capture: true });
+      unsubscribeNav();
+    }
   };
-  const onPopState = () => emitNavigate();
-  document.addEventListener("click", onClick, { capture: true });
-  window.addEventListener("popstate", onPopState);
-  const origPushState = history.pushState;
-  const origReplaceState = history.replaceState;
-  let historyPatched = false;
+  active4 = handle;
+  return handle;
+}
+
+// src/session-lifecycle.ts
+var SESSION_START_EVENT = "session.start";
+var SESSION_END_EVENT = "session.end";
+var SWEEP_INTERVAL_MS = 6e4;
+var MOUSEMOVE_THROTTLE_MS = 1e3;
+var ACTIVITY_EVENTS = ["click", "keydown", "scroll"];
+var active5 = null;
+function emitLifecycle(logger, event) {
+  if (event.type === "start") {
+    resetSessionIdCache();
+    const attrs = { [SESSION_ID_ATTRIBUTE]: event.id };
+    if (event.previousId) attrs["session.previous_id"] = event.previousId;
+    emitSessionEvent(logger, SESSION_START_EVENT, attrs);
+  } else {
+    emitSessionEvent(logger, SESSION_END_EVENT, {
+      [SESSION_ID_ATTRIBUTE]: event.id,
+      "session.duration_ms": String(event.durationMs)
+    });
+  }
+}
+function startSessionLifecycle(options) {
+  if (active5) return active5;
+  let logger = null;
   try {
-    history.pushState = function(...args) {
-      origPushState.apply(this, args);
-      emitNavigate();
-    };
-    history.replaceState = function(...args) {
-      origReplaceState.apply(this, args);
-      emitNavigate();
+    logger = setupOtelLogs(options);
+  } catch (err) {
+    console.warn("[observ] session lifecycle: logs setup failed; events disabled.", err);
+  }
+  const unsubscribe = addSessionListener((event) => {
+    if (logger) emitLifecycle(logger, event);
+  });
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    const handle2 = {
+      stop() {
+        unsubscribe();
+        active5 = null;
+      }
     };
-    historyPatched = true;
-  } catch {
+    active5 = handle2;
+    return handle2;
   }
+  const onActivity = () => {
+    try {
+      touchSession();
+    } catch {
+    }
+  };
+  let lastMove = 0;
+  const onMouseMove = () => {
+    const now = Date.now();
+    if (now - lastMove < MOUSEMOVE_THROTTLE_MS) return;
+    lastMove = now;
+    onActivity();
+  };
+  for (const evt of ACTIVITY_EVENTS) {
+    window.addEventListener(evt, onActivity, { passive: true });
+  }
+  window.addEventListener("mousemove", onMouseMove, { passive: true });
+  const onHide = () => {
+    try {
+      endSessionIfExpired();
+    } catch {
+    }
+  };
+  const onVisibility = () => {
+    if (document.visibilityState === "hidden") onHide();
+  };
+  window.addEventListener("pagehide", onHide);
+  document.addEventListener("visibilitychange", onVisibility);
+  const onStorage = (e) => {
+    if (e.key !== SESSION_STORAGE_KEY || e.newValue == null) return;
+    try {
+      adoptStoredSession();
+      resetSessionIdCache();
+    } catch {
+    }
+  };
+  window.addEventListener("storage", onStorage);
+  const sweepTimer = setInterval(() => {
+    try {
+      endSessionIfExpired();
+    } catch {
+    }
+  }, SWEEP_INTERVAL_MS);
   let stopped = false;
   const handle = {
-    async stop() {
+    stop() {
       if (stopped) return;
       stopped = true;
-      active2 = null;
-      document.removeEventListener("click", onClick, { capture: true });
-      window.removeEventListener("popstate", onPopState);
-      if (historyPatched) {
-        try {
-          history.pushState = origPushState;
-          history.replaceState = origReplaceState;
-        } catch {
-        }
-      }
+      active5 = null;
+      unsubscribe();
+      clearInterval(sweepTimer);
+      for (const evt of ACTIVITY_EVENTS) window.removeEventListener(evt, onActivity);
+      window.removeEventListener("mousemove", onMouseMove);
+      window.removeEventListener("pagehide", onHide);
+      document.removeEventListener("visibilitychange", onVisibility);
+      window.removeEventListener("storage", onStorage);
     }
   };
-  active2 = handle;
+  active5 = handle;
   return handle;
 }
 
@@ -790,10 +1278,40 @@ function startSemanticEvents(options) {
 var replayRecorder = null;
 var semanticEvents = null;
 var jsErrors = null;
-var metrics2 = null;
+var metrics = null;
 var baggageUninstall = null;
+var sessionLifecycle = null;
+var consoleForward = null;
+var pageViews = null;
+var pendingConsentOptions = null;
+var lastStartedOptions = null;
+var consentWatcherCleanup = null;
+var CONSENT_POLL_MS = 1500;
 function init(options) {
   try {
+    if (options.requireConsent && !hasAnalyticsConsent(options)) {
+      pendingConsentOptions = options;
+      installConsentWatcher(options);
+      return;
+    }
+    startSdk(options);
+  } catch (err) {
+    console.warn("[observ] RUM init failed; telemetry disabled.", err);
+  }
+}
+function startSdk(options) {
+  try {
+    lastStartedOptions = options;
+    configureSession({
+      inactivityTimeoutMs: options.sessionInactivityMs,
+      maxDurationMs: options.sessionMaxDurationMs,
+      crossTab: options.crossTabSessions
+    });
+    configureUser({ disablePseudoUser: options.disablePseudoUser });
+    getPseudoUserId();
+    if (!sessionLifecycle) {
+      sessionLifecycle = startSessionLifecycle(options);
+    }
     ensureSession();
     setupOtelRum(options);
     if (!options.disableReplay && !replayRecorder) {
@@ -802,11 +1320,17 @@ function init(options) {
     if (!semanticEvents) {
       semanticEvents = startSemanticEvents(options);
     }
+    if (!options.disablePageViews && !pageViews) {
+      pageViews = startPageViews(options);
+    }
     if (!jsErrors) {
       jsErrors = startJsErrorCapture(options);
     }
-    if (!options.disableMetrics && !metrics2) {
-      metrics2 = setupOtelMetrics(options);
+    if (options.forwardConsole && !consoleForward) {
+      consoleForward = startConsoleForward(options);
+    }
+    if (!options.disableMetrics && !metrics) {
+      metrics = setupOtelMetrics(options);
     }
     if (options.propagateBaggage && !baggageUninstall) {
       const backends = [...options.propagateTraceHeaderCorsUrls ?? []];
@@ -821,17 +1345,79 @@ function init(options) {
     console.warn("[observ] RUM setup failed; tracing/replay/events degraded.", err);
   }
 }
+function removeConsentWatcher() {
+  const cleanup = consentWatcherCleanup;
+  consentWatcherCleanup = null;
+  try {
+    cleanup?.();
+  } catch {
+  }
+}
+function startFromConsent(options) {
+  removeConsentWatcher();
+  pendingConsentOptions = null;
+  startSdk(options);
+}
+function installConsentWatcher(options) {
+  if (consentWatcherCleanup || typeof window === "undefined") return;
+  const key = consentKey(options);
+  const tryStart = () => {
+    if (hasAnalyticsConsent(options)) startFromConsent(options);
+  };
+  const onStorage = (e) => {
+    if (e.key === key) tryStart();
+  };
+  window.addEventListener("storage", onStorage);
+  const interval = setInterval(tryStart, CONSENT_POLL_MS);
+  consentWatcherCleanup = () => {
+    window.removeEventListener("storage", onStorage);
+    clearInterval(interval);
+  };
+}
+function grantConsent() {
+  const options = pendingConsentOptions;
+  if (!options) return;
+  writeConsent(options);
+  startFromConsent(options);
+}
+function revokeConsent() {
+  const options = pendingConsentOptions ?? lastStartedOptions;
+  if (options) clearConsent(options);
+  removeConsentWatcher();
+  pendingConsentOptions = null;
+  void shutdown();
+}
 async function shutdown() {
+  removeConsentWatcher();
+  pendingConsentOptions = null;
   const recorder = replayRecorder;
   const events = semanticEvents;
   const errors = jsErrors;
-  const metricsHandle = metrics2;
+  const metricsHandle = metrics;
   const uninstallBaggage = baggageUninstall;
+  const lifecycle = sessionLifecycle;
+  const consoleHandle = consoleForward;
+  const pageViewsHandle = pageViews;
   replayRecorder = null;
   semanticEvents = null;
   jsErrors = null;
-  metrics2 = null;
+  metrics = null;
   baggageUninstall = null;
+  sessionLifecycle = null;
+  consoleForward = null;
+  pageViews = null;
+  try {
+    consoleHandle?.stop();
+  } catch {
+  }
+  try {
+    pageViewsHandle?.stop();
+  } catch {
+  }
+  try {
+    lifecycle?.stop();
+  } catch {
+  }
   try {
     uninstallBaggage?.();
   } catch {
@@ -861,9 +1447,16 @@ async function shutdown() {
   } catch {
   }
 }
-var observ = { init, shutdown };
+var observ = {
+  init,
+  shutdown,
+  setUser,
+  clearUser,
+  grantConsent,
+  revokeConsent
+};
 var index_default = observ;
 
-export { SESSION_ID_ATTRIBUTE, index_default as default, init, observ, shutdown };
+export { SESSION_ID_ATTRIBUTE, clearUser, index_default as default, grantConsent, init, observ, revokeConsent, setUser, shutdown };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map