@faststats/web 0.7.0 → 0.8.1

package/README.md

@@ -2,3 +2,70 @@
 
 > [!IMPORTANT]
 > This repository is in early development and not intended for production use.
+
+The base SDK only handles analytics, identity, sessions, navigation, and consent.
+Error tracking, Web Vitals, and session replay are independent extensions, so
+applications only download the products they use.
+
+```ts
+import { init, track } from "@faststats/web";
+import { errorTracking } from "@faststats/web/error";
+import { outboundLinks } from "@faststats/web/outbound-links";
+import { sessionReplay } from "@faststats/web/replay";
+import { webVitals } from "@faststats/web/web-vitals";
+
+init({
+	siteKey: "site_123",
+	extensions: [
+		outboundLinks(),
+		errorTracking(),
+		webVitals({ attribution: true }),
+		sessionReplay({ recordConsole: true }),
+	],
+});
+
+track("checkout_completed", { total: 42 });
+```
+
+`init()` starts one shared client and is idempotent, making it safe to call from
+application bootstrap code. Calls made before initialization are ignored rather
+than buffered with stale context. Use `shutdown()` before initializing with new
+options.
+
+For multiple sites, tests, or framework integrations, create an independent
+client with explicit lifecycle control:
+
+```ts
+import { createClient } from "@faststats/web";
+
+const analytics = createClient({ siteKey: "site_123" });
+analytics.start();
+analytics.track("checkout_completed", { total: 42 });
+analytics.destroy();
+```
+
+Consent remains client-local: use `"anonymous"` for cookieless collection,
+`"granted"` for normal collection, or `"denied"` to keep the client dormant.
+
+### Custom extensions
+
+An extension registers only the lifecycle hooks it needs. Hook failures are
+isolated from analytics collection, asynchronous setup is safe during teardown,
+and cleanup receives `discard: true` when consent is revoked.
+
+```ts
+import type { AnalyticsExtension } from "@faststats/web";
+
+export function diagnostics(): AnalyticsExtension {
+	return {
+		name: "diagnostics",
+		setup(context) {
+			const off = context.on("pageChange", ({ url }) => {
+				console.debug("page changed", url, context.getSession());
+			});
+
+			return () => off();
+		},
+	};
+}
+```

package/dist/chunks/{api-urls-Dp2XNjRF.js → api-urls-DWk43fu6.js}

@@ -1,6 +1,5 @@
 //#region src/utils/api-urls.ts
 const ANALYTICS_BASE = "https://metrics.faststats.dev";
-const FEATURE_FLAGS_BASE = "https://flags.faststats.dev";
 function resolveBaseUrl(input, fallback) {
 	return input?.replace(/\/+$/, "") || fallback;
 }
@@ -8,8 +7,7 @@ const URLS = {
 	events: "/v1/web",
 	identify: "/v1/identify",
 	replay: "/v1/replay",
-	vitals: "/v1/vitals",
-	flags: "/v1/check"
+	vitals: "/v1/vitals"
 };
 function sanitizeUrl(url, includeHash = false) {
 	try {
@@ -26,12 +24,21 @@ const UTM_KEYS = [
 	"utm_term",
 	"utm_content"
 ];
+function getReferrer() {
+	const raw = document.referrer;
+	if (!raw) return null;
+	try {
+		const pageOrigin = new URL(location.href).origin;
+		if (new URL(raw, location.href).origin === pageOrigin) return null;
+	} catch {}
+	return sanitizeUrl(raw);
+}
 function getPageContext(includeHash = false) {
 	const hash = includeHash ? location.hash : "";
 	const ctx = {
 		page: `${location.pathname}${hash}`,
 		url: sanitizeUrl(location.href, includeHash),
-		referrer: document.referrer ? sanitizeUrl(document.referrer) : null,
+		referrer: getReferrer(),
 		title: document.title || ""
 	};
 	if (!location.search) return ctx;
@@ -43,4 +50,4 @@ function getPageContext(includeHash = false) {
 	return ctx;
 }
 //#endregion
-export { resolveBaseUrl as a, getPageContext as i, FEATURE_FLAGS_BASE as n, sanitizeUrl as o, URLS as r, ANALYTICS_BASE as t };
+export { sanitizeUrl as a, resolveBaseUrl as i, URLS as n, getPageContext as r, ANALYTICS_BASE as t };

package/dist/chunks/extensions-DW7tJY0T.d.ts

@@ -0,0 +1,51 @@
+//#region src/utils/session-manager.d.ts
+type SessionContext = {
+  sessionId: string;
+  windowId: string;
+  sessionStart: number;
+};
+//#endregion
+//#region src/extensions.d.ts
+type ExtensionHooks = {
+  pageChange: {
+    url: string;
+  };
+  pageHide: {
+    persisted: boolean;
+    terminal: boolean;
+  };
+  pageShow: {
+    persisted: boolean;
+  };
+  consentChange: {
+    cookieless: boolean;
+  };
+  error: {
+    error: Error;
+  };
+};
+type ExtensionHook = keyof ExtensionHooks;
+type ExtensionHandler<K extends ExtensionHook> = (event: ExtensionHooks[K]) => void | Promise<void>;
+interface AnalyticsExtensionContext {
+  readonly siteKey: string;
+  readonly baseUrl: string;
+  readonly debug: boolean;
+  readonly trackHash: boolean;
+  readonly sdkName?: string;
+  readonly sdkVersion?: string;
+  isCookieless(): boolean;
+  getAnonymousId(): string;
+  getSession(): SessionContext;
+  capture(event: string, properties?: Record<string, unknown>): void;
+  on<K extends ExtensionHook>(hook: K, handler: ExtensionHandler<K>): () => void;
+  log(message: string, ...details: unknown[]): void;
+}
+interface AnalyticsExtension {
+  readonly name: string;
+  setup(context: AnalyticsExtensionContext): ExtensionCleanup | undefined | Promise<ExtensionCleanup | undefined>;
+}
+type ExtensionCleanup = (options: {
+  discard: boolean;
+}) => void;
+//#endregion
+export { ExtensionHook as a, ExtensionHandler as i, AnalyticsExtensionContext as n, ExtensionHooks as o, ExtensionCleanup as r, AnalyticsExtension as t };

package/dist/chunks/{identifiers-BvRNbiwA.js → identifiers-KgQDX74Q.js}

@@ -1,4 +1,4 @@
-import { d as setStorageItem, i as isCookielessMode, l as getStorageItem, n as createId, u as removeStorageItem } from "./send-data-DR1JUXka.js";
+import { c as removeStorageItem, l as setStorageItem, n as createId, s as getStorageItem } from "./send-data-DFZnsaL2.js";
 //#region src/utils/identifiers.ts
 const ANONYMOUS_ID_KEY = "faststats_anon_id_";
 function getOrCreateAnonymousId(siteKey) {
@@ -8,8 +8,8 @@ function getOrCreateAnonymousId(siteKey) {
 	const newId = createId();
 	return setStorageItem("localStorage", key, newId) ? newId : "";
 }
-function getAnonymousId(siteKey, cookieless) {
-	if (cookieless ?? isCookielessMode()) return "";
+function getAnonymousId(siteKey, cookieless = false) {
+	if (cookieless) return "";
 	return getOrCreateAnonymousId(siteKey);
 }
 function resetAnonymousId(siteKey, cookieless) {

package/dist/chunks/{send-data-DR1JUXka.js → send-data-DFZnsaL2.js}

@@ -28,18 +28,38 @@ function removeStorageItem(name, key) {
 }
 //#endregion
 //#region src/utils/session-manager.ts
-const IDLE_MS = 1800 * 1e3;
-const MAX_AGE_MS = 1440 * 60 * 1e3;
+const IDLE_MS = 18e5;
+const MAX_AGE_MS = 864e5;
 const SESSION_KEY = "faststats_session_";
-let cookielessMode = false;
+const NO_STORAGE = {};
 const memorySessions = /* @__PURE__ */ new Map();
-const rotationListeners = /* @__PURE__ */ new Set();
+const rotationListeners = /* @__PURE__ */ new Map();
+function memoryKey(siteKey, cookieless) {
+	return `${siteKey}:${cookieless ? "memory" : "persistent"}`;
+}
+function storageScope() {
+	try {
+		return globalThis.localStorage ?? NO_STORAGE;
+	} catch {
+		return NO_STORAGE;
+	}
+}
+function readMemory(siteKey, cookieless) {
+	const entry = memorySessions.get(memoryKey(siteKey, cookieless));
+	return entry?.scope === storageScope() ? entry.session : null;
+}
+function writeMemory(siteKey, cookieless, session) {
+	memorySessions.set(memoryKey(siteKey, cookieless), {
+		scope: storageScope(),
+		session
+	});
+}
 function createId() {
 	if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
 	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
 function readSession(siteKey) {
-	const memory = memorySessions.get(siteKey) ?? null;
+	const memory = readMemory(siteKey, false);
 	const raw = getStorageItem("localStorage", `${SESSION_KEY}${siteKey}`);
 	if (!raw) return memory;
 	try {
@@ -49,29 +69,29 @@ function readSession(siteKey) {
 	return memory;
 }
 function writeSession(siteKey, session) {
-	if (!setStorageItem("localStorage", `${SESSION_KEY}${siteKey}`, JSON.stringify(session))) memorySessions.set(siteKey, session);
+	if (!setStorageItem("localStorage", `${SESSION_KEY}${siteKey}`, JSON.stringify(session))) writeMemory(siteKey, false, session);
 }
-function clearSession(siteKey) {
-	memorySessions.delete(siteKey);
-	removeStorageItem("localStorage", `${SESSION_KEY}${siteKey}`);
+function clearSession(siteKey, cookieless) {
+	memorySessions.delete(memoryKey(siteKey, cookieless));
+	if (!cookieless) removeStorageItem("localStorage", `${SESSION_KEY}${siteKey}`);
 }
 function expired(session, now) {
 	return now - session.activity >= IDLE_MS || now - session.start >= MAX_AGE_MS;
 }
-function emitRotation(prev, next) {
-	for (const listener of rotationListeners) listener(prev, next);
+function emitRotation(siteKey, cookieless, prev, next) {
+	for (const listener of rotationListeners.get(memoryKey(siteKey, cookieless)) ?? []) listener(prev, next);
 }
 function resolveSession(siteKey, cookieless, touch) {
 	const now = Date.now();
 	if (cookieless) {
-		let session = memorySessions.get(siteKey);
+		let session = readMemory(siteKey, true) ?? void 0;
 		if (!session) {
 			session = {
 				id: createId(),
 				start: now,
 				activity: now
 			};
-			memorySessions.set(siteKey, session);
+			writeMemory(siteKey, true, session);
 		} else if (touch) session.activity = now;
 		return {
 			session,
@@ -115,52 +135,50 @@ function toContext(siteKey, session, cookieless, windowIdOverride) {
 		sessionStart: session.start
 	};
 }
-function setCookielessMode(mode) {
-	if (cookielessMode === mode) return;
-	cookielessMode = mode;
-	memorySessions.clear();
-}
-function isCookielessMode() {
-	return cookielessMode;
-}
-function getSessionContext(siteKey, cookieless) {
-	const useCookieless = cookieless ?? cookielessMode;
-	const { session, rotatedFrom } = resolveSession(siteKey, useCookieless, false);
-	const next = toContext(siteKey, session, useCookieless);
-	if (rotatedFrom) emitRotation(toContext(siteKey, rotatedFrom, useCookieless, next.windowId), next);
+function getSessionContext(siteKey, cookieless = false) {
+	const { session, rotatedFrom } = resolveSession(siteKey, cookieless, false);
+	const next = toContext(siteKey, session, cookieless);
+	if (rotatedFrom) emitRotation(siteKey, cookieless, toContext(siteKey, rotatedFrom, cookieless, next.windowId), next);
 	return next;
 }
-function touchActivity(siteKey, cookieless) {
-	const useCookieless = cookieless ?? cookielessMode;
-	const { session, rotatedFrom } = resolveSession(siteKey, useCookieless, true);
+function touchActivity(siteKey, cookieless = false) {
+	const { session, rotatedFrom } = resolveSession(siteKey, cookieless, true);
 	if (!rotatedFrom) return null;
-	const wid = windowId(siteKey, useCookieless, session.id);
+	const wid = windowId(siteKey, cookieless, session.id);
 	const rotation = {
-		prev: toContext(siteKey, rotatedFrom, useCookieless, wid),
-		next: toContext(siteKey, session, useCookieless, wid)
+		prev: toContext(siteKey, rotatedFrom, cookieless, wid),
+		next: toContext(siteKey, session, cookieless, wid)
 	};
-	emitRotation(rotation.prev, rotation.next);
+	emitRotation(siteKey, cookieless, rotation.prev, rotation.next);
 	return rotation;
 }
-function resetSession(siteKey) {
-	const useCookieless = cookielessMode;
-	const previous = getSessionContext(siteKey, useCookieless);
-	clearSession(siteKey);
-	if (useCookieless) {
+function resetSession(siteKey, cookieless = false) {
+	const previous = getSessionContext(siteKey, cookieless);
+	clearSession(siteKey, cookieless);
+	if (cookieless) {
 		const now = Date.now();
-		memorySessions.set(siteKey, {
+		writeMemory(siteKey, true, {
 			id: createId(),
 			start: now,
 			activity: now
 		});
 	} else removeStorageItem("sessionStorage", `faststats_window_id_${siteKey}`);
-	const next = getSessionContext(siteKey, useCookieless);
-	if (previous.sessionId !== next.sessionId) emitRotation(previous, next);
+	const next = getSessionContext(siteKey, cookieless);
+	if (previous.sessionId !== next.sessionId) emitRotation(siteKey, cookieless, previous, next);
 	return next;
 }
-function onSessionRotated(listener) {
-	rotationListeners.add(listener);
-	return () => rotationListeners.delete(listener);
+function onSessionRotated(siteKey, cookieless, listener) {
+	const key = memoryKey(siteKey, cookieless);
+	let listeners = rotationListeners.get(key);
+	if (!listeners) {
+		listeners = /* @__PURE__ */ new Set();
+		rotationListeners.set(key, listeners);
+	}
+	listeners.add(listener);
+	return () => {
+		listeners?.delete(listener);
+		if (listeners?.size === 0) rotationListeners.delete(key);
+	};
 }
 //#endregion
 //#region src/utils/send-data.ts
@@ -198,4 +216,4 @@ async function sendData(options) {
 	}
 }
 //#endregion
-export { onSessionRotated as a, touchActivity as c, setStorageItem as d, isCookielessMode as i, getStorageItem as l, createId as n, resetSession as o, getSessionContext as r, setCookielessMode as s, sendData as t, removeStorageItem as u };
+export { resetSession as a, removeStorageItem as c, onSessionRotated as i, setStorageItem as l, createId as n, touchActivity as o, getSessionContext as r, getStorageItem as s, sendData as t };

package/dist/error.d.ts

@@ -1,3 +1,4 @@
+import { t as AnalyticsExtension } from "./chunks/extensions-DW7tJY0T.js";
 //#region src/error.d.ts
 type ErrorEntry = {
   error: string;
@@ -10,11 +11,14 @@ interface ErrorTrackingOptions {
   baseUrl?: string;
   debug?: boolean;
   trackHash?: boolean;
+  cookieless?: boolean;
   flushInterval?: number;
   maxQueueSize?: number;
   sdkName?: string;
   sdkVersion?: string;
 }
+type ErrorTrackingExtensionOptions = Omit<ErrorTrackingOptions, "siteKey" | "baseUrl" | "debug" | "trackHash" | "cookieless" | "sdkName" | "sdkVersion">;
+declare function errorTracking(options?: ErrorTrackingExtensionOptions): AnalyticsExtension;
 declare class ErrorTracker {
   private readonly options;
   private readonly endpoint;
@@ -22,8 +26,9 @@ declare class ErrorTracker {
   private timer;
   private started;
   private flushing;
+  private cookieless;
   constructor(options: ErrorTrackingOptions);
-  private log;
+  setCookielessMode(cookieless: boolean): void;
   start(): void;
   stop(discard?: boolean): void;
   onPageHidden(persisted?: boolean): void;
@@ -34,4 +39,4 @@ declare class ErrorTracker {
   private flush;
 }
 //#endregion
-export { ErrorEntry, ErrorTrackingOptions, ErrorTracker as default };
+export { ErrorEntry, ErrorTrackingExtensionOptions, ErrorTrackingOptions, ErrorTracker as default, errorTracking };

package/dist/error.js

@@ -1,10 +1,32 @@
-import { a as resolveBaseUrl, i as getPageContext, r as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-Dp2XNjRF.js";
-import { r as getSessionContext, t as sendData } from "./chunks/send-data-DR1JUXka.js";
-import { t as getAnonymousId } from "./chunks/identifiers-BvRNbiwA.js";
+import { i as resolveBaseUrl, n as URLS, r as getPageContext, t as ANALYTICS_BASE } from "./chunks/api-urls-DWk43fu6.js";
+import { r as getSessionContext, t as sendData } from "./chunks/send-data-DFZnsaL2.js";
+import { t as getAnonymousId } from "./chunks/identifiers-KgQDX74Q.js";
 //#region src/error.ts
 const SDK_NAME = "@faststats/web";
-const SDK_VERSION = "0.7.0";
-const EXTENSION_RE = /(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;
+const SDK_VERSION = "0.8.1";
+function errorTracking(options = {}) {
+	return {
+		name: "error-tracking",
+		setup(context) {
+			const tracker = new ErrorTracker({
+				...options,
+				siteKey: context.siteKey,
+				baseUrl: context.baseUrl,
+				debug: context.debug,
+				trackHash: context.trackHash,
+				cookieless: context.isCookieless(),
+				sdkName: context.sdkName,
+				sdkVersion: context.sdkVersion
+			});
+			context.on("pageHide", ({ persisted }) => tracker.onPageHidden(persisted));
+			context.on("error", ({ error }) => tracker.captureError(error));
+			context.on("consentChange", ({ cookieless }) => tracker.setCookielessMode(cookieless));
+			tracker.start();
+			return ({ discard }) => tracker.stop(discard);
+		}
+	};
+}
+const EXTENSION_URL = /(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;
 function toEntry(kind, source, handled, fallback) {
 	if (source instanceof Error) return {
 		error: kind === "UnhandledRejection" ? kind : source.name.trim() || kind,
@@ -20,7 +42,7 @@ function toEntry(kind, source, handled, fallback) {
 }
 function isExtensionError(filename, source) {
 	const stack = source instanceof Error ? source.stack ?? "" : "";
-	return EXTENSION_RE.test(`${filename}\n${stack}`);
+	return EXTENSION_URL.test(filename) || EXTENSION_URL.test(stack);
 }
 var ErrorTracker = class {
 	options;
@@ -29,12 +51,15 @@ var ErrorTracker = class {
 	timer = null;
 	started = false;
 	flushing = false;
+	cookieless;
 	constructor(options) {
 		this.options = options;
 		this.endpoint = `${resolveBaseUrl(options.baseUrl, ANALYTICS_BASE)}${URLS.events}`;
+		this.cookieless = options.cookieless ?? false;
 	}
-	log(...args) {
-		if (this.options.debug) console.log("[ErrorTracker]", ...args);
+	setCookielessMode(cookieless) {
+		if (this.cookieless !== cookieless) this.queue = [];
+		this.cookieless = cookieless;
 	}
 	start() {
 		if (this.started || typeof window === "undefined") return;
@@ -42,7 +67,6 @@ var ErrorTracker = class {
 		window.addEventListener("error", this.onError);
 		window.addEventListener("unhandledrejection", this.onRejection);
 		this.timer = setInterval(() => void this.flush(), this.options.flushInterval ?? 5e3);
-		this.log("Started");
 	}
 	stop(discard = false) {
 		if (!this.started || typeof window === "undefined") return;
@@ -53,7 +77,6 @@ var ErrorTracker = class {
 		this.timer = null;
 		if (discard) this.queue = [];
 		else this.flush();
-		this.log("Stopped");
 	}
 	onPageHidden(persisted = false) {
 		if (!persisted) this.flush();
@@ -71,9 +94,8 @@ var ErrorTracker = class {
 	};
 	enqueue(error) {
 		const buildId = globalThis.__SOURCEMAPS_BUILD__?.buildId;
-		const userId = getAnonymousId(this.options.siteKey);
-		const ctx = getSessionContext(this.options.siteKey);
-		this.log("Captured:", error);
+		const userId = getAnonymousId(this.options.siteKey, this.cookieless);
+		const ctx = getSessionContext(this.options.siteKey, this.cookieless);
 		this.queue.push({
 			error,
 			context: {
@@ -132,4 +154,4 @@ var ErrorTracker = class {
 	}
 };
 //#endregion
-export { ErrorTracker as default };
+export { ErrorTracker as default, errorTracking };

package/dist/index.d.ts

@@ -1,60 +1,40 @@
-import { FeatureFlagEvaluation } from "./feature-flags.js";
-import { n as ReplayTrackerOptions } from "./chunks/replay-BeC2XA4N.js";
-
+import { a as ExtensionHook, i as ExtensionHandler, n as AnalyticsExtensionContext, o as ExtensionHooks, r as ExtensionCleanup, t as AnalyticsExtension } from "./chunks/extensions-DW7tJY0T.js";
 //#region src/analytics.d.ts
-type ConsentMode = "pending" | "granted" | "denied";
-type PendingBehavior = "anonymous" | "disabled";
+type ConsentMode = "anonymous" | "granted" | "denied";
 interface IdentifyOptions {
-  name?: string;
-  phone?: string;
-  avatarUrl?: string;
+  name?: string | null;
+  phone?: string | null;
+  avatarUrl?: string | null;
   traits?: Record<string, unknown>;
+  traitMode?: "merge" | "replace";
+  unsetTraits?: string[];
+  aliases?: string[];
+}
+interface IdentifyUser extends IdentifyOptions {
+  id: string;
+  email?: string | null;
 }
 interface WebAnalyticsOptions {
   siteKey: string;
   baseUrl?: string;
-  featureFlagsBaseUrl?: string;
   debug?: boolean;
-  autoTrack?: boolean;
   trackHash?: boolean;
   cookieless?: boolean;
-  consent?: {
-    mode?: ConsentMode;
-    pendingBehavior?: PendingBehavior;
-  };
-  webVitals?: {
-    enabled?: boolean;
-    attribution?: boolean;
-  };
-  sessionReplays?: {
-    enabled?: boolean;
-  };
-  errorTracking?: {
-    enabled?: boolean;
-  };
-  replayOptions?: Partial<ReplayTrackerOptions>;
+  consent?: ConsentMode;
+  extensions?: readonly AnalyticsExtension[];
   /** @internal */
   sdkName?: string;
   /** @internal */
   sdkVersion?: string;
 }
-declare function getInstance(): WebAnalytics | null;
-declare function trackEvent(eventName: string, properties?: Record<string, unknown>): void;
-declare function identify(externalId: string, email: string, options?: IdentifyOptions): Promise<boolean>;
-declare function logout(resetAnonymousIdentity?: boolean): void;
-declare function setConsentMode(mode: ConsentMode): void;
-declare function optIn(): void;
-declare function optOut(): void;
-declare function reportError(error: Error): void;
-declare function isTrackingDisabled(): boolean;
 declare class WebAnalytics {
   private readonly options;
   private readonly baseUrl;
   private readonly debug;
+  private readonly cleanup;
   private started;
-  private destroyed;
-  private epoch;
   private heartbeatTimer;
+  private extensions;
   private pageKey;
   private entry;
   private left;
@@ -62,51 +42,53 @@ declare class WebAnalytics {
   private visitStartedAt;
   private pendingPageviewTrigger;
   private consentMode;
-  private readonly pendingBehavior;
-  private readonly cleanup;
-  private readonly childTrackers;
-  private readonly outboundLinks;
   constructor(options: WebAnalyticsOptions);
-  private log;
-  private isTrackingBlocked;
-  private ensureActive;
-  private canTrack;
-  private canSendEvents;
-  private cookieless;
-  private touch;
-  private bind;
-  private stopHeartbeat;
-  private loadChild;
-  private loadOptionalTrackers;
-  private enterPage;
-  private beginTracking;
-  private readonly onLinkClick;
-  private readonly onVisibilityChange;
-  private readonly onPageHide;
-  private readonly onPageShow;
-  start(): Promise<void>;
+  start(): void;
   destroy(): void;
-  pageview(extra?: Record<string, unknown>): void;
-  track(name: string, extra?: Record<string, unknown>): void;
-  identify(externalId: string, email: string, options?: IdentifyOptions): Promise<boolean>;
+  pageview(properties?: Record<string, unknown>): void;
+  track(name: string, properties?: Record<string, unknown>): void;
+  identify(user: IdentifyUser): Promise<boolean>;
+  identify(externalId: string, email?: string, options?: IdentifyOptions): Promise<boolean>;
   logout(resetAnonymousIdentity?: boolean): void;
   setConsentMode(mode: ConsentMode): void;
-  getConsentMode(): ConsentMode;
   getAnonymousId(): string;
-  getSessionId(): string;
-  getWindowId(): string;
-  checkFeatureFlag(key: string, attributes?: Record<string, unknown>, opts?: {
-    externalId?: string;
-    signal?: AbortSignal;
-  }): Promise<FeatureFlagEvaluation>;
   reportError(error: Error): void;
-  private send;
+  private canTrack;
+  private isCookieless;
+  private ensureActive;
+  private activate;
+  private startExtensions;
+  private stopExtensions;
+  private installBrowserLifecycle;
+  private bind;
+  private readonly onNavigate;
+  private readonly onVisibilityChange;
+  private readonly onPageHide;
+  private readonly onPageShow;
+  private navigate;
+  private enterPage;
   private leavePage;
-  private startVisit;
   private pauseVisit;
   private resumeVisit;
+  private touch;
   private startHeartbeat;
-  private navigate;
+  private stopHeartbeat;
+  private send;
 }
 //#endregion
-export { type ConsentMode, type FeatureFlagEvaluation, type IdentifyOptions, type PendingBehavior, WebAnalytics, type WebAnalyticsOptions, getInstance, identify, isTrackingDisabled, logout, optIn, optOut, reportError, setConsentMode, trackEvent };
+//#region src/client.d.ts
+/** Creates an independent client. Call `start()` when it should begin tracking. */
+declare function createClient(options: WebAnalyticsOptions): WebAnalytics;
+/** Initializes and starts the shared client used by the convenience functions. */
+declare function init(options: WebAnalyticsOptions): WebAnalytics;
+/** Stops and forgets the shared client. Independent clients are unaffected. */
+declare function shutdown(): void;
+declare function pageview(properties?: Record<string, unknown>): void;
+declare function track(name: string, properties?: Record<string, unknown>): void;
+declare function identify(user: IdentifyUser): Promise<boolean>;
+declare function identify(externalId: string, email?: string, options?: IdentifyOptions): Promise<boolean>;
+declare function logout(resetAnonymousIdentity?: boolean): void;
+declare function setConsentMode(mode: ConsentMode): void;
+declare function reportError(error: Error): void;
+//#endregion
+export { type AnalyticsExtension, type AnalyticsExtensionContext, type ConsentMode, type ExtensionCleanup, type ExtensionHandler, type ExtensionHook, type ExtensionHooks, type IdentifyOptions, type IdentifyUser, WebAnalytics, type WebAnalyticsOptions, createClient, identify, init, logout, pageview, reportError, setConsentMode, shutdown, track };