@faststats/web 0.10.3 → 0.12.0

package/README.md

@@ -3,21 +3,20 @@
 > [!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.
+The base SDK handles analytics, identity, sessions, navigation, outbound link
+clicks, and consent.
+Error tracking, Web Vitals, session replay, and feature flags 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(),
 		sessionReplay({ recordConsole: true }),
@@ -78,6 +77,55 @@ since the last delivered checkpoint. The collector must accept successive events
 for the same visitor and URL; deploy the removal of its five-second debounce
 before releasing this SDK.
 
+### Feature flags
+
+`featureFlags()` loads the project's flags for the visitor the client tracks and
+resolves them synchronously from memory:
+
+```ts
+import { init } from "@faststats/web";
+import { featureFlags } from "@faststats/web/flags";
+
+const flags = featureFlags({ flags: ["new-checkout", "max-uploads"] });
+init({ siteKey: "site_123", extensions: [flags] });
+
+await flags.ready();
+if (flags.isEnabled("new-checkout")) showNewCheckout();
+const maxUploads = flags.get("max-uploads", 10);
+```
+
+Every loaded flag is recorded as an exposure, whether or not the app reads it,
+so list the keys the app uses in `flags`. Without it every flag in the project
+is loaded.
+
+Flags are evaluated for the anonymous visitor ID, and the session ID links each
+evaluation to analytics. `identify()` re-evaluates them for that user, so
+rollouts follow the user across devices, and `logout()` goes back to a new
+anonymous visitor. When the user is known at startup, pass `userId` to skip the
+anonymous load. A cookieless visitor has no lasting ID, so rollouts hold for the
+session only. Flags are not loaded while consent is `"denied"`.
+
+`get()` returns the default passed at the call site while flags are loading, and
+when the flag does not exist, is archived, has a different type, or the service
+cannot be reached within `timeoutMs`. `details(key)` adds the variant and reason
+(`rule_match`, `target_match`, `fallthrough`, `disabled`,
+`prerequisite_failed`).
+
+```ts
+flags.subscribe(() => render(flags.status)); // "idle" | "loading" | "ready" | "error"
+await flags.setContext({ attributes: { plan: "pro" } });
+await flags.reload();
+```
+
+| Option       |                                                          |
+| ------------ | -------------------------------------------------------- |
+| `flags`      | The flag keys to load.                                   |
+| `userId`     | Your ID for a signed-in user, when known at startup.     |
+| `attributes` | Anything targeting rules should match on.                |
+| `endpoint`   | Base URL of the flags service, when self-run.            |
+| `timeoutMs`  | Aborts a slower load. Defaults to `3000`.                |
+| `fetch`      | A `fetch` implementation to use instead of the global.   |
+
 ### Network recording in session replay
 
 Network recording is disabled by default. Enable it with
@@ -123,7 +171,7 @@ export function diagnostics(): AnalyticsExtension {
 		name: "diagnostics",
 		setup(context) {
 			const off = context.on("pageChange", ({ url }) => {
-				console.debug("page changed", url, context.getSession());
+				console.debug("page changed", url);
 			});
 
 			return () => off();

package/dist/chunks/{extensions-DW7tJY0T.d.ts → extensions-BfubKIzk.d.ts}

@@ -1,10 +1,3 @@
-//#region src/utils/session-manager.d.ts
-type SessionContext = {
-  sessionId: string;
-  windowId: string;
-  sessionStart: number;
-};
-//#endregion
 //#region src/extensions.d.ts
 type ExtensionHooks = {
   pageChange: {
@@ -20,6 +13,10 @@ type ExtensionHooks = {
   consentChange: {
     cookieless: boolean;
   };
+  /** `identify()` set a user, or `logout()` cleared one. */
+  identityChange: {
+    userId: string | undefined;
+  };
   error: {
     error: Error;
   };
@@ -34,11 +31,7 @@ interface AnalyticsExtensionContext {
   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;

package/dist/chunks/{identifiers-BgGtAQdp.js → identifiers-CpmDmpDv.js}

@@ -1,4 +1,4 @@
-import { c as removeStorageItem, l as setStorageItem, n as createId, s as getStorageItem } from "./send-data-DAVUdfNm.js";
+import { c as setStorageItem, o as getStorageItem, s as removeStorageItem, t as createId } from "./session-manager-CFQEWbgo.js";
 //#region src/utils/identifiers.ts
 const ANONYMOUS_ID_KEY = "faststats_anon_id_";
 function getAnonymousId(siteKey, cookieless = false) {

package/dist/chunks/send-data-DYZZjeM-.js

@@ -0,0 +1,84 @@
+//#region src/utils/api-urls.ts
+function resolveBaseUrl(baseUrl) {
+	return baseUrl?.replace(/\/+$/, "") || "https://metrics.faststats.dev";
+}
+const URLS = {
+	events: "/v1/web",
+	identify: "/v1/identify",
+	replay: "/v1/replay",
+	vitals: "/v1/vitals"
+};
+function sanitizeUrl(url, includeHash = false) {
+	try {
+		const parsed = new URL(url, location.href);
+		return `${parsed.origin}${parsed.pathname}${includeHash ? parsed.hash : ""}`;
+	} catch {
+		return url.split(includeHash ? "?" : /[?#]/, 1)[0] ?? "";
+	}
+}
+const UTM_KEYS = [
+	"utm_source",
+	"utm_medium",
+	"utm_campaign",
+	"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: getReferrer(),
+		title: document.title || ""
+	};
+	if (!location.search) return ctx;
+	const sp = new URLSearchParams(location.search);
+	for (const key of UTM_KEYS) {
+		const value = sp.get(key);
+		if (value) ctx[key] = value;
+	}
+	return ctx;
+}
+//#endregion
+//#region src/utils/send-data.ts
+async function sendData(options) {
+	const { url, data, contentType = "application/json", debug = false, debugPrefix = "[Analytics]", useBeacon = true, keepalive = true, settleRejected } = options;
+	if (useBeacon && typeof globalThis.navigator?.sendBeacon === "function") try {
+		const beaconBody = data instanceof Blob || typeof Blob === "undefined" ? data : new Blob([data], { type: contentType });
+		if (globalThis.navigator.sendBeacon(url, beaconBody)) {
+			if (debug) console.log(`${debugPrefix} Sent via beacon`);
+			return true;
+		}
+	} catch {}
+	const size = typeof data === "string" ? data.length : data instanceof Blob ? data.size : data.byteLength;
+	const post = (keepalive) => fetch(url, {
+		method: "POST",
+		body: data,
+		headers: { "Content-Type": contentType },
+		keepalive,
+		credentials: "omit"
+	});
+	try {
+		const useKeepalive = keepalive && size <= 61440;
+		const { ok, status } = await post(useKeepalive).catch((error) => {
+			if (!useKeepalive) throw error;
+			return post(false);
+		});
+		if (debug) console.log(debugPrefix, ok ? "Sent via fetch" : status);
+		return ok || !!settleRejected && status < 500 && status !== 429;
+	} catch {
+		if (debug) console.log(debugPrefix, "Failed to send");
+		return false;
+	}
+}
+//#endregion
+export { sanitizeUrl as a, resolveBaseUrl as i, URLS as n, getPageContext as r, sendData as t };

package/dist/chunks/{send-data-DAVUdfNm.js → session-manager-CFQEWbgo.js}

@@ -31,6 +31,7 @@ function removeStorageItem(name, key) {
 const IDLE_MS = 18e5;
 const MAX_AGE_MS = 864e5;
 const SESSION_KEY = "faststats_session_";
+const WINDOW_KEY = "faststats_window_id_";
 const NO_STORAGE = {};
 const memorySessions = /* @__PURE__ */ new Map();
 const rotationListeners = /* @__PURE__ */ new Map();
@@ -64,7 +65,7 @@ function readSession(siteKey) {
 	if (!raw) return memory;
 	try {
 		const session = JSON.parse(raw);
-		return typeof session?.id === "string" && session.id && Number.isFinite(session.start) && Number.isFinite(session.activity) ? session : memory;
+		if (typeof session?.id === "string" && session.id && Number.isFinite(session.start) && Number.isFinite(session.activity)) return session;
 	} catch {}
 	return memory;
 }
@@ -104,7 +105,7 @@ function resolveSession(siteKey, cookieless, touch) {
 }
 function windowId(siteKey, cookieless, sessionId) {
 	if (cookieless) return sessionId;
-	const key = `faststats_window_id_${siteKey}`;
+	const key = `${WINDOW_KEY}${siteKey}`;
 	const existing = getStorageItem("sessionStorage", key);
 	if (existing) return existing;
 	const id = createId();
@@ -128,7 +129,7 @@ function resetSession(siteKey, cookieless = false) {
 	memorySessions.delete(memoryKey(siteKey, cookieless));
 	if (!cookieless) {
 		removeStorageItem("localStorage", `${SESSION_KEY}${siteKey}`);
-		removeStorageItem("sessionStorage", `faststats_window_id_${siteKey}`);
+		removeStorageItem("sessionStorage", `${WINDOW_KEY}${siteKey}`);
 	}
 	const next = getSessionContext(siteKey, cookieless);
 	if (previous.sessionId !== next.sessionId) emitRotation(siteKey, cookieless, previous, next);
@@ -148,35 +149,4 @@ function onSessionRotated(siteKey, cookieless, listener) {
 	};
 }
 //#endregion
-//#region src/utils/send-data.ts
-async function sendData(options) {
-	const { url, data, contentType = "application/json", headers = {}, debug = false, debugPrefix = "[Analytics]", useBeacon = true, keepalive = true, signal, settleRejected } = options;
-	if (signal?.aborted) return false;
-	if (useBeacon && typeof globalThis.navigator?.sendBeacon === "function") try {
-		const beaconBody = data instanceof Blob || typeof Blob === "undefined" ? data : new Blob([data], { type: contentType });
-		if (globalThis.navigator.sendBeacon(url, beaconBody)) {
-			if (debug) console.log(`${debugPrefix} Sent via beacon`);
-			return true;
-		}
-	} catch {}
-	try {
-		const { ok, status } = await fetch(url, {
-			method: "POST",
-			body: data,
-			headers: {
-				"Content-Type": contentType,
-				...headers
-			},
-			keepalive,
-			credentials: "omit",
-			signal
-		});
-		if (debug) console.log(debugPrefix, ok ? "Sent via fetch" : status);
-		return ok || !!settleRejected && status < 500 && status !== 429;
-	} catch {
-		if (debug) console.log(debugPrefix, "Failed to send");
-		return false;
-	}
-}
-//#endregion
-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 };
+export { touchActivity as a, setStorageItem as c, resetSession as i, getSessionContext as n, getStorageItem as o, onSessionRotated as r, removeStorageItem as s, createId as t };

package/dist/error.d.ts

@@ -1,4 +1,4 @@
-import { t as AnalyticsExtension } from "./chunks/extensions-DW7tJY0T.js";
+import { t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
 //#region src/error.d.ts
 export type ErrorEntry = {
   error: string;
@@ -17,7 +17,7 @@ export interface ErrorTrackingOptions {
   sdkName?: string;
   sdkVersion?: string;
 }
-export type ErrorTrackingExtensionOptions = Omit<ErrorTrackingOptions, "siteKey" | "baseUrl" | "debug" | "trackHash" | "cookieless" | "sdkName" | "sdkVersion">;
+export type ErrorTrackingExtensionOptions = Pick<ErrorTrackingOptions, "flushInterval" | "maxQueueSize">;
 export declare function errorTracking(options?: ErrorTrackingExtensionOptions): AnalyticsExtension;
 export default class ErrorTracker {
   private readonly options;
@@ -26,11 +26,14 @@ export default class ErrorTracker {
   private timer;
   private started;
   private flushing;
+  private generation;
   private cookieless;
+  private readonly maxQueueSize;
   constructor(options: ErrorTrackingOptions);
   setCookielessMode(cookieless: boolean): void;
   start(): void;
   stop(discard?: boolean): void;
+  private discard;
   onPageHidden(persisted?: boolean): void;
   captureError(error: Error): void;
   private onError;

package/dist/error.js

@@ -1,9 +1,9 @@
-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-DAVUdfNm.js";
-import { t as getAnonymousId } from "./chunks/identifiers-BgGtAQdp.js";
+import { i as resolveBaseUrl, n as URLS, r as getPageContext, t as sendData } from "./chunks/send-data-DYZZjeM-.js";
+import { n as getSessionContext } from "./chunks/session-manager-CFQEWbgo.js";
+import { t as getAnonymousId } from "./chunks/identifiers-CpmDmpDv.js";
 //#region src/error.ts
 const SDK_NAME = "@faststats/web";
-const SDK_VERSION = "0.10.3";
+const SDK_VERSION = "0.12.0";
 function errorTracking(options = {}) {
 	return {
 		name: "error-tracking",
@@ -51,14 +51,17 @@ var ErrorTracker = class {
 	timer = null;
 	started = false;
 	flushing = false;
+	generation = 0;
 	cookieless;
+	maxQueueSize;
 	constructor(options) {
 		this.options = options;
-		this.endpoint = `${resolveBaseUrl(options.baseUrl, ANALYTICS_BASE)}${URLS.events}`;
+		this.maxQueueSize = options.maxQueueSize ?? 50;
+		this.endpoint = `${resolveBaseUrl(options.baseUrl)}${URLS.events}`;
 		this.cookieless = options.cookieless ?? false;
 	}
 	setCookielessMode(cookieless) {
-		if (this.cookieless !== cookieless) this.queue = [];
+		if (this.cookieless !== cookieless) this.discard();
 		this.cookieless = cookieless;
 	}
 	start() {
@@ -69,15 +72,19 @@ var ErrorTracker = class {
 		this.timer = setInterval(() => void this.flush(), this.options.flushInterval ?? 5e3);
 	}
 	stop(discard = false) {
-		if (!this.started || typeof window === "undefined") return;
+		if (!this.started) return;
 		this.started = false;
 		window.removeEventListener("error", this.onError);
 		window.removeEventListener("unhandledrejection", this.onRejection);
 		if (this.timer) clearInterval(this.timer);
 		this.timer = null;
-		if (discard) this.queue = [];
+		if (discard) this.discard();
 		else this.flush();
 	}
+	discard() {
+		this.generation++;
+		this.queue = [];
+	}
 	onPageHidden(persisted = false) {
 		if (!persisted) this.flush();
 	}
@@ -111,11 +118,12 @@ var ErrorTracker = class {
 				properties: {}
 			}
 		});
-		if (this.queue.length >= (this.options.maxQueueSize ?? 50)) this.flush();
+		if (this.queue.length >= this.maxQueueSize) this.flush();
 	}
 	async flush() {
 		if (this.flushing || !this.queue.length) return;
 		this.flushing = true;
+		const generation = this.generation;
 		const batch = this.queue;
 		this.queue = [];
 		const groups = /* @__PURE__ */ new Map();
@@ -128,29 +136,36 @@ var ErrorTracker = class {
 			group.items.push(item);
 			groups.set(key, group);
 		}
-		const failed = await Promise.all([...groups.values()].map(async (group) => {
-			const errors = /* @__PURE__ */ new Map();
-			for (const { error } of group.items) {
-				const key = JSON.stringify(error);
-				const existing = errors.get(key);
-				if (existing) existing.count++;
-				else errors.set(key, {
-					...error,
-					count: 1
-				});
-			}
-			return await sendData({
-				url: this.endpoint,
-				data: JSON.stringify({
-					...group.context,
-					errors: [...errors.values()]
-				}),
-				debug: this.options.debug,
-				debugPrefix: "[ErrorTracker]"
-			}) ? [] : group.items;
-		}));
-		this.queue.unshift(...failed.flat());
-		this.flushing = false;
+		let failed = [];
+		try {
+			failed = (await Promise.all([...groups.values()].map(async (group) => {
+				const errors = /* @__PURE__ */ new Map();
+				for (const { error } of group.items) {
+					const key = JSON.stringify(error);
+					const existing = errors.get(key);
+					if (existing) existing.count++;
+					else errors.set(key, {
+						...error,
+						count: 1
+					});
+				}
+				return await sendData({
+					url: this.endpoint,
+					data: JSON.stringify({
+						...group.context,
+						errors: [...errors.values()]
+					}),
+					debug: this.options.debug,
+					debugPrefix: "[ErrorTracker]",
+					settleRejected: true
+				}) ? [] : group.items;
+			}))).flat();
+		} finally {
+			this.flushing = false;
+		}
+		if (generation !== this.generation) return;
+		this.queue = [...failed, ...this.queue].slice(-this.maxQueueSize);
+		if (!this.started && !failed.length) this.flush();
 	}
 };
 //#endregion

package/dist/flags.d.ts

@@ -0,0 +1,79 @@
+import { n as AnalyticsExtensionContext, r as ExtensionCleanup, t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
+//#region src/flags.d.ts
+export interface FeatureFlagsOptions {
+  /**
+   * Flag keys this app reads. Every loaded flag is recorded as an exposure,
+   * so list them to keep flags the app never shows out of analytics.
+   * Loads every flag when omitted.
+   */
+  flags?: string[];
+  /** Your own ID for a signed-in user. Rollouts follow it across devices. */
+  userId?: string;
+  /** Anything targeting rules should match on. */
+  attributes?: Record<string, unknown>;
+  /** Base URL of the feature flags service. */
+  endpoint?: string;
+  /** Aborts a load that takes longer, so flags serve their defaults. */
+  timeoutMs?: number;
+  fetch?: typeof fetch;
+}
+export type FeatureFlagReason = "disabled" | "prerequisite_failed" | "target_match" | "rule_match" | "fallthrough";
+export interface FeatureFlagResult {
+  value: unknown;
+  variant: string;
+  reason: FeatureFlagReason;
+}
+export interface FeatureFlagsContext {
+  /** Pass `null` to go back to the anonymous visitor. */
+  userId?: string | null;
+  /** Replaces the attributes set before. */
+  attributes?: Record<string, unknown>;
+}
+/**
+ * `idle` until the client starts tracking, `loading` during the first load
+ * for a visitor, then `ready`, or `error` when that load failed.
+ */
+export type FeatureFlagsStatus = "idle" | "loading" | "ready" | "error";
+/**
+ * Loads flags from the FastStats flags service for the visitor the analytics
+ * client tracks and resolves them synchronously from memory.
+ */
+export declare class FeatureFlags implements AnalyticsExtension {
+  private readonly options;
+  readonly name = "feature-flags";
+  private readonly listeners;
+  private context;
+  private results;
+  private currentStatus;
+  private latestLoad;
+  private subjectKey;
+  private loading;
+  private userId;
+  private attributes;
+  constructor(options?: FeatureFlagsOptions);
+  setup(context: AnalyticsExtensionContext): ExtensionCleanup;
+  get status(): FeatureFlagsStatus;
+  /**
+   * The flag's value, or `defaultValue` while flags are loading, when the flag
+   * does not exist or is archived, or when its type differs from the default's.
+   */
+  get(key: string, defaultValue: boolean): boolean;
+  get(key: string, defaultValue: string): string;
+  get(key: string, defaultValue: number): number;
+  get<T>(key: string, defaultValue: T): T;
+  isEnabled(key: string): boolean;
+  details(key: string): FeatureFlagResult | undefined;
+  /** Changes who flags are evaluated for and loads them again. */
+  setContext(context: FeatureFlagsContext): Promise<void>;
+  /** Resolves once the load in flight settles. Never rejects. */
+  ready(): Promise<void>;
+  /** Loads the flags again. Never rejects; a failed load sets `status`. */
+  reload(): Promise<void>;
+  /** Calls `listener` whenever the flags or `status` change. */
+  subscribe(listener: () => void): () => void;
+  private subject;
+  private evaluate;
+  private update;
+}
+export declare function featureFlags(options?: FeatureFlagsOptions): FeatureFlags;
+//#endregion

package/dist/flags.js

@@ -0,0 +1,145 @@
+import { n as getSessionContext } from "./chunks/session-manager-CFQEWbgo.js";
+import { t as getAnonymousId } from "./chunks/identifiers-CpmDmpDv.js";
+//#region src/flags.ts
+const DEFAULT_ENDPOINT = "https://flags.faststats.dev";
+const DEFAULT_TIMEOUT_MS = 3e3;
+/**
+* Loads flags from the FastStats flags service for the visitor the analytics
+* client tracks and resolves them synchronously from memory.
+*/
+var FeatureFlags = class {
+	options;
+	name = "feature-flags";
+	listeners = /* @__PURE__ */ new Set();
+	context = null;
+	results = {};
+	currentStatus = "idle";
+	latestLoad = 0;
+	subjectKey = "";
+	loading = null;
+	userId;
+	attributes;
+	constructor(options = {}) {
+		this.options = options;
+		this.userId = options.userId;
+		this.attributes = options.attributes;
+	}
+	setup(context) {
+		this.context = context;
+		context.on("identityChange", ({ userId }) => {
+			this.userId = userId;
+			this.reload();
+		});
+		context.on("consentChange", () => void this.reload());
+		this.reload();
+		return () => {
+			if (this.context !== context) return;
+			this.context = null;
+			this.latestLoad++;
+			this.loading = null;
+			this.subjectKey = "";
+			this.update({}, "idle");
+		};
+	}
+	get status() {
+		return this.currentStatus;
+	}
+	get(key, defaultValue) {
+		const result = this.details(key);
+		if (!result) return defaultValue;
+		const type = typeof defaultValue;
+		if ((type === "boolean" || type === "string" || type === "number") && typeof result.value !== type) return defaultValue;
+		return result.value;
+	}
+	isEnabled(key) {
+		return this.get(key, false);
+	}
+	details(key) {
+		return Object.hasOwn(this.results, key) ? this.results[key] : void 0;
+	}
+	/** Changes who flags are evaluated for and loads them again. */
+	setContext(context) {
+		if (context.userId !== void 0) this.userId = context.userId?.trim() || void 0;
+		if (context.attributes) this.attributes = context.attributes;
+		return this.reload();
+	}
+	/** Resolves once the load in flight settles. Never rejects. */
+	ready() {
+		return this.loading ?? Promise.resolve();
+	}
+	/** Loads the flags again. Never rejects; a failed load sets `status`. */
+	reload() {
+		const context = this.context;
+		if (!context) return Promise.resolve();
+		const load = ++this.latestLoad;
+		const subject = this.subject(context);
+		if (subject.key !== this.subjectKey) {
+			this.subjectKey = subject.key;
+			this.update({}, "loading");
+		}
+		const loading = this.evaluate(context, subject.body).then((results) => {
+			if (load === this.latestLoad) this.update(results, "ready");
+		}, (error) => {
+			if (context.debug) console.log("[FastStats] flags failed", error);
+			if (load !== this.latestLoad) return;
+			if (this.currentStatus === "loading") this.update({}, "error");
+		}).finally(() => {
+			if (this.loading === loading) this.loading = null;
+		});
+		this.loading = loading;
+		return loading;
+	}
+	/** Calls `listener` whenever the flags or `status` change. */
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	subject(context) {
+		const cookieless = context.isCookieless();
+		const { sessionId } = getSessionContext(context.siteKey, cookieless);
+		const identifier = getAnonymousId(context.siteKey, cookieless) || sessionId;
+		return {
+			key: JSON.stringify([identifier, this.userId]),
+			body: {
+				identifier,
+				userId: this.userId,
+				sessionId,
+				attributes: this.attributes ?? {},
+				flags: this.options.flags && [...new Set(this.options.flags)]
+			}
+		};
+	}
+	async evaluate(context, body) {
+		const endpoint = (this.options.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, "");
+		const response = await (this.options.fetch ?? fetch)(`${endpoint}/v1/evaluate`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				authorization: `Bearer ${context.siteKey}`
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+			cache: "no-store"
+		});
+		if (!response.ok) throw new Error(`Evaluation failed with status ${response.status}`);
+		const data = await response.json();
+		if (typeof data?.flags !== "object" || data.flags === null) throw new Error("Unexpected response from the flags service");
+		return data.flags;
+	}
+	update(results, status) {
+		this.results = results;
+		this.currentStatus = status;
+		for (const listener of [...this.listeners]) try {
+			listener();
+		} catch (error) {
+			if (this.context?.debug) console.log("[FastStats] flags listener failed", error);
+		}
+	}
+};
+function featureFlags(options = {}) {
+	return new FeatureFlags(options);
+}
+//#endregion
+export { FeatureFlags, featureFlags };