@grafana-experiments/sdk 0.0.0 → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,846 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createExperimentEnricher: () => createExperimentEnricher,
+  createExperiments: () => createExperiments,
+  createTypedReporter: () => createTypedReporter,
+  defineEvent: () => defineEvent,
+  toOpenFeatureTrackingDetails: () => toOpenFeatureTrackingDetails
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/experiments.ts
+var import_web_sdk2 = require("@openfeature/web-sdk");
+
+// src/faro.ts
+function createFaroReporter(faro) {
+  let owned;
+  let sequence = 0;
+  function finish(reason, reportingEnabled = true) {
+    const active = faro.api.getActiveUserAction();
+    if (!owned || active !== owned) {
+      owned = void 0;
+      return;
+    }
+    const action = owned;
+    owned = void 0;
+    if (!reportingEnabled) {
+      action.cancel();
+      return;
+    }
+    action.attributes = { ...action.attributes, end_reason: reason };
+    action.end();
+  }
+  return {
+    report(name, properties, type) {
+      const attributes = stringifyAttributes(properties);
+      if (type === "custom-event") {
+        faro.api.pushEvent(name, attributes, void 0, { skipDedupe: true });
+        return;
+      }
+      if (!faro.instrumentations.instrumentations.some(
+        (item) => item.name === "@grafana/faro-web-sdk:instrumentation-user-action"
+      )) {
+        faro.api.pushEvent(
+          name,
+          { ...attributes, action_fallback: "instrumentation-unavailable" },
+          void 0,
+          { skipDedupe: true }
+        );
+        return;
+      }
+      finish("superseded");
+      if (faro.api.getActiveUserAction()) {
+        faro.api.pushEvent(name, { ...attributes, action_fallback: "host-action-active" }, void 0, {
+          skipDedupe: true
+        });
+        return;
+      }
+      owned = faro.api.startUserAction(name, {
+        ...attributes,
+        experiment_action_sequence: String(sequence++)
+      });
+      if (!owned) {
+        faro.api.pushEvent(name, { ...attributes, action_fallback: "start-unavailable" }, void 0, {
+          skipDedupe: true
+        });
+      }
+    },
+    finish
+  };
+}
+function stringifyAttributes(properties) {
+  const result = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    try {
+      const text = typeof value === "object" ? JSON.stringify(value) : String(value);
+      if (text !== void 0) {
+        result[key] = text;
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+
+// src/events.ts
+function defineEvent(definition) {
+  return definition;
+}
+function createTypedReporter(sdk, definitions) {
+  const installed = sdk.getEventManifest().events;
+  for (const [name, definition] of Object.entries(definitions)) {
+    if (JSON.stringify(installed[name]) !== JSON.stringify(definition))
+      throw new Error(`Event contract not installed: ${name}`);
+  }
+  return (name, properties, options) => sdk.reportAnalytics(name, properties, options);
+}
+function validateEvent(definition, properties) {
+  if (!definition) return [];
+  return Object.entries(definition.properties).flatMap(([key, rule]) => {
+    const value = properties[key];
+    return value === void 0 && !rule.required ? [] : typeof value !== rule.type || typeof value === "number" && !Number.isFinite(value) ? [key] : [];
+  });
+}
+
+// src/enrichment.ts
+function createExperimentEnricher(options) {
+  return (input) => {
+    let item = input;
+    if (options.isEnabled?.() !== false && ["event", "exception", "measurement"].includes(input.type)) {
+      const payload = input.payload;
+      const key = input.type === "event" ? "attributes" : "context";
+      const attributes = { ...payload[key] };
+      if (!("experiments" in attributes)) {
+        const timestamp = Date.parse(String(payload.timestamp));
+        const measurementStart = Number(attributes.experiment_started_at);
+        const origin = input.type === "measurement" ? measurementStart : timestamp;
+        const assignments = options.getAssignments().filter((a) => Number.isFinite(origin) && a.activated_at && Date.parse(a.activated_at) <= origin);
+        attributes.experiments = JSON.stringify(assignments);
+      }
+      attributes.event_id ||= crypto.randomUUID();
+      attributes.telemetry_schema_version = "2";
+      item = { ...input, payload: { ...payload, [key]: attributes } };
+    }
+    return options.beforeSend ? options.beforeSend(item) : item;
+  };
+}
+
+// src/semconv.ts
+function featureFlagAttributes(flagKey, details, options) {
+  const attributes = { "feature_flag.key": flagKey };
+  if (details.variant) {
+    attributes["feature_flag.result.variant"] = details.variant;
+  } else if (options.recordValue) {
+    attributes["feature_flag.result.value"] = details.value;
+  }
+  if (details.reason) {
+    attributes["feature_flag.result.reason"] = details.reason.toLowerCase();
+  }
+  if (options.providerName) {
+    attributes["feature_flag.provider.name"] = options.providerName;
+  }
+  for (const [metadataKey, attribute] of [
+    ["contextId", "feature_flag.context.id"],
+    ["flagSetId", "feature_flag.set.id"],
+    ["version", "feature_flag.version"]
+  ]) {
+    const value = details.flagMetadata?.[metadataKey];
+    if (typeof value === "string" || typeof value === "number") {
+      attributes[attribute] = String(value);
+    }
+  }
+  return attributes;
+}
+
+// src/readiness.ts
+var import_web_sdk = require("@openfeature/web-sdk");
+function waitForReady(client, timeout, signal) {
+  if (signal?.aborted) {
+    return Promise.resolve(false);
+  }
+  if (client.providerStatus === import_web_sdk.ClientProviderStatus.READY) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve) => {
+    let timer;
+    const finish = (ready) => {
+      clearTimeout(timer);
+      client.removeHandler(import_web_sdk.ProviderEvents.Ready, onReady);
+      client.removeHandler(import_web_sdk.ProviderEvents.Error, onError);
+      signal?.removeEventListener("abort", onError);
+      resolve(ready);
+    };
+    const onReady = () => finish(true);
+    const onError = () => finish(false);
+    client.addHandler(import_web_sdk.ProviderEvents.Ready, onReady);
+    client.addHandler(import_web_sdk.ProviderEvents.Error, onError);
+    signal?.addEventListener("abort", onError, { once: true });
+    timer = setTimeout(onError, timeout);
+    if (client.providerStatus === import_web_sdk.ClientProviderStatus.READY) {
+      onReady();
+    }
+  });
+}
+
+// src/experiments.ts
+var INACTIVE = Object.freeze({ status: "inactive" });
+function createExperiments(options) {
+  if (!options.scope.trim()) {
+    throw new Error("An application scope is required");
+  }
+  const timeout = options.readinessTimeoutMs ?? 1e4;
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new Error("readinessTimeoutMs must be positive and finite");
+  }
+  let disposed = false;
+  let contextKey = options.contextKey ?? "default";
+  let sessionId;
+  let generation = 0;
+  let identityGeneration = 0;
+  const diagnostics = [];
+  let diagnosticSequence = 0;
+  const diagnosticListeners = /* @__PURE__ */ new Set();
+  function diagnose(code, fields = {}) {
+    const diagnostic = Object.freeze({
+      sequence: ++diagnosticSequence,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      code,
+      ...fields
+    });
+    diagnostics.push(diagnostic);
+    if (diagnostics.length > 200) diagnostics.shift();
+    for (const listener of [options.onDiagnostic, ...diagnosticListeners]) {
+      try {
+        listener?.(diagnostic);
+      } catch {
+      }
+    }
+  }
+  let faro = options.faro.instance;
+  let mirror = faro ? createFaroReporter(faro) : void 0;
+  let initializing;
+  let pausedByConsent = false;
+  const lifetime = new AbortController();
+  const entries = /* @__PURE__ */ new Map();
+  function error(value) {
+    diagnose("reporting-error", { detail: value instanceof Error ? value.message : String(value) });
+    try {
+      options.onError?.(value);
+    } catch {
+    }
+  }
+  function attempt(work) {
+    try {
+      void Promise.resolve(work()).catch(error);
+    } catch (value) {
+      error(value);
+    }
+  }
+  function enabled() {
+    try {
+      return !disposed && (options.isEnabled?.() ?? true);
+    } catch (value) {
+      error(value);
+      return false;
+    }
+  }
+  function storage() {
+    if (options.storage !== void 0) {
+      return options.storage;
+    }
+    try {
+      return typeof sessionStorage === "undefined" ? null : sessionStorage;
+    } catch {
+      return null;
+    }
+  }
+  function resolveSession() {
+    try {
+      const host = options.getSessionId?.();
+      if (typeof host === "string" && host.trim()) {
+        return host;
+      }
+    } catch (value) {
+      error(value);
+    }
+    try {
+      const fallback = faro?.api.getSession()?.id;
+      return typeof fallback === "string" && fallback.trim() ? fallback : void 0;
+    } catch (value) {
+      error(value);
+      return void 0;
+    }
+  }
+  function syncSession() {
+    const allowed = enabled();
+    if (faro && options.faro.config) {
+      attempt(() => {
+        if (!allowed && !faro.transports.isPaused()) {
+          faro.pause();
+          pausedByConsent = true;
+        } else if (allowed && pausedByConsent) {
+          faro.unpause();
+          pausedByConsent = false;
+        }
+      });
+    }
+    const next = allowed ? resolveSession() : void 0;
+    if (next === sessionId) {
+      return;
+    }
+    sessionId = next;
+    generation++;
+    identityGeneration++;
+    for (const entry of entries.values()) {
+      entry.reset();
+    }
+  }
+  const onMetaChange = () => {
+    attempt(syncSession);
+  };
+  const onProviderReady = () => {
+    for (const entry of entries.values()) {
+      entry.retry();
+    }
+  };
+  options.client.addHandler(import_web_sdk2.ProviderEvents.Ready, onProviderReady);
+  options.client.addHandler(import_web_sdk2.ProviderEvents.ConfigurationChanged, onProviderReady);
+  faro?.metas.addListener(onMetaChange);
+  async function initialize() {
+    if (faro || disposed || !enabled()) {
+      return;
+    }
+    if (initializing) {
+      return initializing;
+    }
+    initializing = (async () => {
+      try {
+        const { initializeFaro, UserActionInstrumentation } = await import("@grafana/faro-web-sdk");
+        if (disposed || !enabled() || !options.faro.config) {
+          return;
+        }
+        const configured = options.faro.config.instrumentations;
+        const instrumentations = configured && !configured.some((item) => item.name === "@grafana/faro-web-sdk:instrumentation-user-action") ? [...configured, new UserActionInstrumentation()] : configured;
+        const initialized = initializeFaro({
+          preventGlobalExposure: true,
+          ...options.faro.config,
+          isolate: true,
+          instrumentations,
+          beforeSend: options.enrichFaro ? createExperimentEnricher({
+            getAssignments: () => sdk.getActiveAssignments(),
+            isEnabled: enabled,
+            beforeSend: options.faro.config.beforeSend
+          }) : options.faro.config.beforeSend
+        });
+        if (!initialized) {
+          throw new Error("Faro initialization did not return an instance");
+        }
+        faro = initialized;
+        mirror = createFaroReporter(faro);
+        faro.metas.addListener(onMetaChange);
+        syncSession();
+      } catch (value) {
+        error(value);
+      }
+    })();
+    await initializing;
+    initializing = void 0;
+  }
+  function sendFaro(name, properties, type) {
+    const report2 = () => {
+      if (!enabled()) {
+        return;
+      }
+      const transformed = options.transformFaroProperties ? options.transformFaroProperties(name, properties) : properties;
+      if (transformed !== null) {
+        if (mirror) {
+          diagnose("faro-attempted", { eventName: name });
+          mirror.report(name, transformed, type);
+        }
+      } else {
+        diagnose("faro-filtered", { eventName: name });
+      }
+    };
+    attempt(() => mirror ? report2() : initialize().then(report2));
+  }
+  function copyProperties(properties) {
+    const result = {};
+    for (const [key, value] of Object.entries(properties)) {
+      try {
+        result[key] = structuredClone(value);
+      } catch (value2) {
+        error(value2);
+      }
+    }
+    return result;
+  }
+  const sdk = {
+    ready: initialize(),
+    defineExperiment(definition) {
+      if (disposed) {
+        throw new Error("Experiments instance is disposed");
+      }
+      if (!definition.id.trim() || !definition.flagKey.trim()) {
+        throw new Error("Experiment id and flagKey are required");
+      }
+      if (entries.has(definition.id)) {
+        throw new Error(`Experiment already defined: ${definition.id}`);
+      }
+      const { id, flagKey, group = "rollout", flag } = definition;
+      let state = INACTIVE;
+      let entryId = "default";
+      let entrySettled = false;
+      let entryGeneration = 0;
+      let history = {};
+      let restored;
+      const settled = () => entrySettled && (state.status === "active" || state.status === "excluded");
+      const listeners = /* @__PURE__ */ new Set();
+      const update = (next) => {
+        state = Object.freeze(next);
+        for (const listener of listeners) {
+          attempt(listener);
+        }
+        return state;
+      };
+      const key = () => `grafana-experiments:v2:${JSON.stringify([options.scope, contextKey, sessionId, id, flagKey, flag.type])}`;
+      function unavailable(reason) {
+        diagnose("activation-unavailable", { experimentId: id, detail: reason });
+        return update({ status: "unavailable", reason });
+      }
+      function parse(value) {
+        if (flag.type === "boolean") {
+          return typeof value === "boolean" ? { variant: value ? "treatment" : "control" } : void 0;
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+          return;
+        }
+        const variant = value.variant;
+        if (!["control", "treatment", "excluded"].includes(variant) || !flag.validate(value)) {
+          return;
+        }
+        return { variant, config: structuredClone(value) };
+      }
+      function assigned(parsed, metadata = {}, source = "unknown") {
+        if (parsed.variant === "excluded") {
+          return { status: "excluded", ...parsed, variant: "excluded" };
+        }
+        const unit = metadata.allocationUnit;
+        if (unit && (!["stack", "organization", "user", "session"].includes(unit.type) || !unit.id?.trim()))
+          throw new Error("Invalid allocation unit");
+        const signature = JSON.stringify([
+          parsed.variant,
+          metadata.revision,
+          unit?.type,
+          unit?.id,
+          metadata.population
+        ]);
+        const previous = history[signature];
+        const assignment = previous ?? {
+          experiment_id: id,
+          experiment_group: group,
+          flag_key: flagKey,
+          variant: parsed.variant,
+          session_id: sessionId,
+          exposure_id: crypto.randomUUID(),
+          activated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          experiment_revision: metadata.revision,
+          allocation_unit_type: unit?.type,
+          allocation_unit_id: unit?.id,
+          population: metadata.population,
+          assignment_source: source
+        };
+        history[signature] = assignment;
+        return {
+          status: "active",
+          ...parsed,
+          variant: parsed.variant,
+          assignment: Object.freeze(assignment)
+        };
+      }
+      entries.set(id, {
+        reset: () => {
+          entrySettled = false;
+          entryGeneration++;
+          history = {};
+          restored = void 0;
+          update(INACTIVE);
+        },
+        retry: () => {
+          if (state.status === "unavailable" && ["provider", "evaluation", "invalid-value"].includes(state.reason)) {
+            update(INACTIVE);
+          }
+        },
+        assignment: () => state.status === "active" ? state.assignment : void 0,
+        storageKey: key
+      });
+      return {
+        id,
+        getSnapshot: () => state,
+        subscribe(listener) {
+          listeners.add(listener);
+          return () => {
+            listeners.delete(listener);
+          };
+        },
+        async activate({ signal, entryId: requestedEntry } = {}) {
+          if (requestedEntry !== void 0 && requestedEntry !== entryId) {
+            entryId = requestedEntry;
+            entryGeneration++;
+            entrySettled = false;
+          }
+          const thisEntry = entryGeneration;
+          if (signal?.aborted) {
+            return INACTIVE;
+          }
+          if (disposed) {
+            return unavailable("disposed");
+          }
+          await initialize();
+          syncSession();
+          if (!enabled()) {
+            return unavailable("disabled");
+          }
+          if (!sessionId) {
+            return unavailable("no-session");
+          }
+          if (signal?.aborted) {
+            return INACTIVE;
+          }
+          if (settled()) {
+            diagnose("exposure-suppressed", { experimentId: id, detail: "same-entry" });
+            return state;
+          }
+          try {
+            const cached = storage()?.getItem(key());
+            if (cached) {
+              const saved = JSON.parse(cached);
+              if (saved.sessionId === sessionId && saved.schemaVersion === 2) {
+                history = saved.history || {};
+                restored = saved;
+                const parsed = parse(saved.value);
+                if (requestedEntry === void 0 && parsed) {
+                  entrySettled = true;
+                  diagnose("exposure-suppressed", { experimentId: id, detail: "session-restored" });
+                  return update(
+                    parsed.variant === "excluded" ? { status: "excluded", ...parsed, variant: "excluded" } : {
+                      status: "active",
+                      ...parsed,
+                      variant: parsed.variant,
+                      assignment: Object.freeze(saved.assignment)
+                    }
+                  );
+                }
+              }
+            }
+          } catch (value) {
+            error(value);
+          }
+          const startGeneration = generation;
+          const activationSignal = signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal;
+          let ready = false;
+          try {
+            ready = await waitForReady(options.client, timeout, activationSignal);
+          } catch (value) {
+            error(value);
+          }
+          syncSession();
+          if (activationSignal.aborted || startGeneration !== generation || thisEntry !== entryGeneration) {
+            return INACTIVE;
+          }
+          if (!enabled()) {
+            return unavailable("disabled");
+          }
+          if (!ready || options.client.providerStatus !== import_web_sdk2.ClientProviderStatus.READY) {
+            return unavailable("provider");
+          }
+          if (settled()) {
+            return state;
+          }
+          try {
+            const details = flag.type === "boolean" ? options.client.getBooleanDetails(flagKey, false) : options.client.getObjectDetails(flagKey, { variant: "excluded" });
+            if (details.errorCode) {
+              return unavailable("evaluation");
+            }
+            const parsed = parse(details.value);
+            if (!parsed) {
+              return unavailable("invalid-value");
+            }
+            const providerMetadata = definition.mapAssignment?.(details);
+            const metadata = { ...definition.metadata, ...providerMetadata };
+            const priorIds = new Set(Object.values(history).map((a) => a.exposure_id));
+            const previous = state.status === "active" ? state.assignment : restored?.assignment;
+            const next = assigned(
+              parsed,
+              metadata,
+              providerMetadata?.allocationUnit ? "provider" : definition.metadata?.allocationUnit ? "host" : "unknown"
+            );
+            entrySettled = true;
+            diagnose("evaluated", {
+              experimentId: id,
+              detail: `${parsed.variant}; ${details.reason ?? "unknown"}`
+            });
+            if (previous && (next.status !== "active" || previous.exposure_id !== next.assignment.exposure_id)) {
+              diagnose("assignment-transition", {
+                experimentId: id,
+                detail: `${previous.variant} \u2192 ${parsed.variant}`
+              });
+              sendFaro(
+                "experiment_assignment_changed",
+                {
+                  experiment_id: id,
+                  previous_exposure_id: previous.exposure_id,
+                  variant: parsed.variant,
+                  event_id: crypto.randomUUID(),
+                  telemetry_schema_version: 2
+                },
+                "custom-event"
+              );
+            }
+            state = Object.freeze(next);
+            try {
+              storage()?.setItem(
+                key(),
+                JSON.stringify({
+                  schemaVersion: 2,
+                  sessionId,
+                  value: details.value,
+                  assignment: next.status === "active" ? next.assignment : void 0,
+                  history
+                })
+              );
+            } catch (value) {
+              error(value);
+            }
+            if (next.status === "active" && !priorIds.has(next.assignment.exposure_id)) {
+              diagnose("activated", { experimentId: id });
+              const properties = {
+                ...next.assignment,
+                ...featureFlagAttributes(flagKey, details, {
+                  providerName: options.client.metadata.providerMetadata?.name,
+                  recordValue: options.recordFlagValue ?? true
+                }),
+                event_id: crypto.randomUUID(),
+                telemetry_schema_version: 2
+              };
+              attempt(
+                () => options.reportExposure ? options.reportExposure(next.assignment) : options.reportAnalytics?.("experiment_viewed", { ...properties })
+              );
+              sendFaro("experiment_viewed", properties, "custom-event");
+            } else {
+              diagnose("exposure-suppressed", {
+                experimentId: id,
+                detail: next.status === "excluded" ? "excluded" : "already-exposed"
+              });
+            }
+            return update(next);
+          } catch (value) {
+            error(value);
+            return unavailable("evaluation");
+          }
+        }
+      };
+    },
+    reportAnalytics(name, properties = {}, reportOptions) {
+      report(name, properties, reportOptions);
+    },
+    getActiveAssignments() {
+      syncSession();
+      return [...entries.values()].flatMap((entry) => {
+        const assignment = entry.assignment();
+        return assignment ? [structuredClone(assignment)] : [];
+      });
+    },
+    getEventManifest: () => structuredClone({ schemaVersion: 2, scope: options.scope, events: options.eventDefinitions ?? {} }),
+    getDiagnostics: () => [...diagnostics],
+    subscribeDiagnostics(listener) {
+      diagnosticListeners.add(listener);
+      return () => {
+        diagnosticListeners.delete(listener);
+      };
+    },
+    beginJourney() {
+      const assignments = sdk.getActiveAssignments();
+      const origin = identityGeneration;
+      const id = crypto.randomUUID();
+      let ended = false;
+      return {
+        id,
+        getTelemetryContext() {
+          syncSession();
+          return {
+            experiments: JSON.stringify(
+              !ended && origin === identityGeneration && enabled() ? assignments : []
+            ),
+            journey_id: id
+          };
+        },
+        end() {
+          ended = true;
+        },
+        reportAnalytics(name, properties = {}, reportOptions) {
+          syncSession();
+          if (ended || origin !== identityGeneration) {
+            diagnose("journey-invalidated", { eventName: name });
+            return;
+          }
+          report(name, properties, reportOptions, assignments, id);
+        }
+      };
+    },
+    refreshSession() {
+      attempt(syncSession);
+      void initialize();
+    },
+    resetContext(nextContextKey) {
+      if (disposed) {
+        return;
+      }
+      attempt(() => mirror?.finish("context-reset", enabled()));
+      if (nextContextKey === contextKey) {
+        for (const entry of entries.values()) {
+          attempt(() => storage()?.removeItem(entry.storageKey()));
+        }
+      }
+      contextKey = nextContextKey;
+      generation++;
+      identityGeneration++;
+      for (const entry of entries.values()) {
+        entry.reset();
+      }
+      syncSession();
+    },
+    dispose() {
+      if (disposed) {
+        return;
+      }
+      attempt(() => mirror?.finish("disposed", enabled()));
+      disposed = true;
+      lifetime.abort();
+      options.client.removeHandler(import_web_sdk2.ProviderEvents.Ready, onProviderReady);
+      options.client.removeHandler(import_web_sdk2.ProviderEvents.ConfigurationChanged, onProviderReady);
+      attempt(() => faro?.metas.removeListener(onMetaChange));
+      if (faro && options.faro.config) {
+        attempt(() => faro.pause());
+        attempt(() => faro.instrumentations.remove(...faro.instrumentations.instrumentations));
+        attempt(() => faro.transports.remove(...faro.transports.transports));
+      }
+      for (const entry of entries.values()) {
+        entry.reset();
+      }
+      entries.clear();
+      diagnosticListeners.clear();
+    }
+  };
+  function report(name, properties, reportOptions, captured, journeyId) {
+    syncSession();
+    if (!enabled()) {
+      diagnose("consent-gated", { eventName: name });
+      return;
+    }
+    const assignments = captured ?? sdk.getActiveAssignments();
+    const definition = options.eventDefinitions?.[name];
+    const invalid = validateEvent(definition, properties);
+    const context = {
+      experiments: structuredClone(assignments),
+      event_id: crypto.randomUUID(),
+      telemetry_schema_version: 2,
+      event_schema_version: definition?.version,
+      ...journeyId ? { journey_id: journeyId } : {}
+    };
+    const enriched = {
+      ...copyProperties(properties),
+      ...structuredClone(context),
+      measurement_valid: invalid.length === 0
+    };
+    const copied = copyProperties(enriched);
+    if (options.reportAnalytics) {
+      diagnose("analytics-attempted", { eventName: name });
+      attempt(() => options.reportAnalytics(name, enriched));
+    }
+    if (invalid.length) {
+      diagnose("schema-invalid", { eventName: name, detail: invalid.join(", ") });
+      sendFaro(
+        "experiment_diagnostic",
+        {
+          code: "schema-invalid",
+          event_name: name,
+          experiments: assignments,
+          event_id: enriched.event_id,
+          telemetry_schema_version: 2
+        },
+        "custom-event"
+      );
+      return;
+    }
+    if (options.openFeatureTracking) {
+      attempt(() => {
+        const details = options.openFeatureTracking(
+          name,
+          copyProperties(properties),
+          structuredClone(context)
+        );
+        if (details) {
+          options.client.track(name, details);
+          diagnose("openfeature-track-attempted", { eventName: name });
+        }
+      });
+    }
+    sendFaro(name, copied, reportOptions?.faro?.type ?? options.events?.[name] ?? "custom-event");
+  }
+  syncSession();
+  return sdk;
+}
+
+// src/tracking.ts
+function toOpenFeatureTrackingDetails(context) {
+  return {
+    event_id: context.event_id,
+    telemetry_schema_version: context.telemetry_schema_version,
+    experiments: context.experiments.map(
+      (assignment) => Object.fromEntries(Object.entries(assignment).filter(([, value]) => value !== void 0))
+    ),
+    ...context.event_schema_version !== void 0 ? { event_schema_version: context.event_schema_version } : {},
+    ...context.journey_id !== void 0 ? { journey_id: context.journey_id } : {}
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createExperimentEnricher,
+  createExperiments,
+  createTypedReporter,
+  defineEvent,
+  toOpenFeatureTrackingDetails
+});