@grafana-experiments/sdk 0.0.0 → 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,35 @@
+import { E as ExperimentsOptions, e as Experiments, f as EventDefinition, R as ReportOptions, A as Assignment, M as MeasurementContext } from './types-M9Kqiiqw.cjs';
+export { g as AllocationUnit, h as AnalyticsReporter, i as AssignmentMetadata, D as Diagnostic, d as EventManifest, c as Experiment, a as ExperimentConfig, b as ExperimentDefinition, j as ExperimentState, F as FaroEventType, J as Journey, P as Properties, V as Variant } from './types-M9Kqiiqw.cjs';
+import { BrowserConfig } from '@grafana/faro-web-sdk';
+import { TrackingEventDetails } from '@openfeature/web-sdk';
+
+declare function createExperiments(options: ExperimentsOptions): Experiments;
+
+declare function defineEvent<const T extends EventDefinition>(definition: T): T;
+type Value<T> = T extends {
+    type: 'number';
+} ? number : T extends {
+    type: 'boolean';
+} ? boolean : string;
+type EventProperties<T extends EventDefinition> = {
+    [K in keyof T['properties'] as T['properties'][K] extends {
+        required: true;
+    } ? K : never]: Value<T['properties'][K]>;
+} & {
+    [K in keyof T['properties'] as T['properties'][K] extends {
+        required: true;
+    } ? never : K]?: Value<T['properties'][K]>;
+};
+declare function createTypedReporter<T extends Record<string, EventDefinition>>(sdk: Experiments, definitions: T): <K extends keyof T & string>(name: K, properties: EventProperties<T[K]>, options?: ReportOptions) => void;
+
+/** Install before Faro initialization; bind getAssignments to the SDK when it exists. */
+declare function createExperimentEnricher(options: {
+    getAssignments: () => readonly Assignment[];
+    isEnabled?: () => boolean;
+    beforeSend?: BrowserConfig['beforeSend'];
+}): NonNullable<BrowserConfig['beforeSend']>;
+
+/** Explicitly opt in to sharing captured attribution with the flag provider. */
+declare function toOpenFeatureTrackingDetails(context: MeasurementContext): TrackingEventDetails;
+
+export { Assignment, EventDefinition, Experiments, ExperimentsOptions, MeasurementContext, ReportOptions, createExperimentEnricher, createExperiments, createTypedReporter, defineEvent, toOpenFeatureTrackingDetails };

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { E as ExperimentsOptions, e as Experiments, f as EventDefinition, R as ReportOptions, A as Assignment, M as MeasurementContext } from './types-M9Kqiiqw.js';
+export { g as AllocationUnit, h as AnalyticsReporter, i as AssignmentMetadata, D as Diagnostic, d as EventManifest, c as Experiment, a as ExperimentConfig, b as ExperimentDefinition, j as ExperimentState, F as FaroEventType, J as Journey, P as Properties, V as Variant } from './types-M9Kqiiqw.js';
+import { BrowserConfig } from '@grafana/faro-web-sdk';
+import { TrackingEventDetails } from '@openfeature/web-sdk';
+
+declare function createExperiments(options: ExperimentsOptions): Experiments;
+
+declare function defineEvent<const T extends EventDefinition>(definition: T): T;
+type Value<T> = T extends {
+    type: 'number';
+} ? number : T extends {
+    type: 'boolean';
+} ? boolean : string;
+type EventProperties<T extends EventDefinition> = {
+    [K in keyof T['properties'] as T['properties'][K] extends {
+        required: true;
+    } ? K : never]: Value<T['properties'][K]>;
+} & {
+    [K in keyof T['properties'] as T['properties'][K] extends {
+        required: true;
+    } ? never : K]?: Value<T['properties'][K]>;
+};
+declare function createTypedReporter<T extends Record<string, EventDefinition>>(sdk: Experiments, definitions: T): <K extends keyof T & string>(name: K, properties: EventProperties<T[K]>, options?: ReportOptions) => void;
+
+/** Install before Faro initialization; bind getAssignments to the SDK when it exists. */
+declare function createExperimentEnricher(options: {
+    getAssignments: () => readonly Assignment[];
+    isEnabled?: () => boolean;
+    beforeSend?: BrowserConfig['beforeSend'];
+}): NonNullable<BrowserConfig['beforeSend']>;
+
+/** Explicitly opt in to sharing captured attribution with the flag provider. */
+declare function toOpenFeatureTrackingDetails(context: MeasurementContext): TrackingEventDetails;
+
+export { Assignment, EventDefinition, Experiments, ExperimentsOptions, MeasurementContext, ReportOptions, createExperimentEnricher, createExperiments, createTypedReporter, defineEvent, toOpenFeatureTrackingDetails };

package/dist/index.js

@@ -0,0 +1,26 @@
+import {
+  createExperimentEnricher,
+  createExperiments,
+  createTypedReporter,
+  defineEvent
+} from "./chunk-W7444I4G.js";
+
+// 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 } : {}
+  };
+}
+export {
+  createExperimentEnricher,
+  createExperiments,
+  createTypedReporter,
+  defineEvent,
+  toOpenFeatureTrackingDetails
+};

package/dist/react.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.tsx
+var react_exports = {};
+__export(react_exports, {
+  ExperimentsProvider: () => ExperimentsProvider,
+  useExperiment: () => useExperiment,
+  useExperiments: () => useExperiments
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var Context = (0, import_react.createContext)(null);
+var serverSnapshot = () => ({ status: "inactive" });
+var INACTIVE = serverSnapshot();
+function ExperimentsProvider({
+  experiments,
+  children
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Context.Provider, { value: experiments, children });
+}
+function useExperiments() {
+  const experiments = (0, import_react.useContext)(Context);
+  if (!experiments) {
+    throw new Error("useExperiments requires ExperimentsProvider");
+  }
+  return experiments;
+}
+function useExperiment(experiment, eligible = true, entryId) {
+  const state = (0, import_react.useSyncExternalStore)(experiment.subscribe, experiment.getSnapshot, () => INACTIVE);
+  (0, import_react.useEffect)(() => {
+    if (!eligible) {
+      return;
+    }
+    const controller = new AbortController();
+    void experiment.activate({ signal: controller.signal, entryId });
+    return () => controller.abort();
+  }, [experiment, eligible, entryId, state.status === "inactive"]);
+  return state;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExperimentsProvider,
+  useExperiment,
+  useExperiments
+});

package/dist/react.d.cts

@@ -0,0 +1,14 @@
+import { e as Experiments, a as ExperimentConfig, c as Experiment, j as ExperimentState } from './types-M9Kqiiqw.cjs';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import '@grafana/faro-web-sdk';
+import '@openfeature/web-sdk';
+
+declare function ExperimentsProvider({ experiments, children, }: {
+    experiments: Experiments;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useExperiments(): Experiments;
+declare function useExperiment<T extends ExperimentConfig>(experiment: Experiment<T>, eligible?: boolean, entryId?: string): ExperimentState<T>;
+
+export { ExperimentsProvider, useExperiment, useExperiments };

package/dist/react.d.ts

@@ -0,0 +1,14 @@
+import { e as Experiments, a as ExperimentConfig, c as Experiment, j as ExperimentState } from './types-M9Kqiiqw.js';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import '@grafana/faro-web-sdk';
+import '@openfeature/web-sdk';
+
+declare function ExperimentsProvider({ experiments, children, }: {
+    experiments: Experiments;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useExperiments(): Experiments;
+declare function useExperiment<T extends ExperimentConfig>(experiment: Experiment<T>, eligible?: boolean, entryId?: string): ExperimentState<T>;
+
+export { ExperimentsProvider, useExperiment, useExperiments };

package/dist/react.js

@@ -0,0 +1,36 @@
+// src/react.tsx
+import { createContext, useContext, useEffect, useSyncExternalStore } from "react";
+import { jsx } from "react/jsx-runtime";
+var Context = createContext(null);
+var serverSnapshot = () => ({ status: "inactive" });
+var INACTIVE = serverSnapshot();
+function ExperimentsProvider({
+  experiments,
+  children
+}) {
+  return /* @__PURE__ */ jsx(Context.Provider, { value: experiments, children });
+}
+function useExperiments() {
+  const experiments = useContext(Context);
+  if (!experiments) {
+    throw new Error("useExperiments requires ExperimentsProvider");
+  }
+  return experiments;
+}
+function useExperiment(experiment, eligible = true, entryId) {
+  const state = useSyncExternalStore(experiment.subscribe, experiment.getSnapshot, () => INACTIVE);
+  useEffect(() => {
+    if (!eligible) {
+      return;
+    }
+    const controller = new AbortController();
+    void experiment.activate({ signal: controller.signal, entryId });
+    return () => controller.abort();
+  }, [experiment, eligible, entryId, state.status === "inactive"]);
+  return state;
+}
+export {
+  ExperimentsProvider,
+  useExperiment,
+  useExperiments
+};

package/dist/types-M9Kqiiqw.d.cts

@@ -0,0 +1,171 @@
+import { Faro, BrowserConfig } from '@grafana/faro-web-sdk';
+import { Client, TrackingEventDetails } from '@openfeature/web-sdk';
+
+type Variant = 'control' | 'treatment' | 'excluded';
+type Properties = Record<string, unknown>;
+type AnalyticsReporter = (name: string, properties: Properties) => void | Promise<void>;
+type FaroEventType = 'custom-event' | 'user-action';
+interface ReportOptions {
+    faro?: {
+        type: FaroEventType;
+    };
+}
+interface ExperimentConfig {
+    variant: Variant;
+}
+interface ExperimentDefinition<T extends ExperimentConfig = ExperimentConfig> {
+    id: string;
+    flagKey: string;
+    group?: string;
+    metadata?: AssignmentMetadata;
+    mapAssignment?: (evaluation: {
+        value: unknown;
+        variant?: string;
+        flagMetadata?: Record<string, unknown>;
+        reason?: string;
+    }) => AssignmentMetadata;
+    flag: {
+        type: 'boolean';
+    } | {
+        type: 'object';
+        validate: (value: unknown) => value is T;
+    };
+}
+interface Assignment {
+    experiment_id: string;
+    experiment_revision?: string;
+    allocation_unit_type?: AllocationUnit['type'];
+    allocation_unit_id?: string;
+    assignment_source?: 'provider' | 'host' | 'unknown';
+    population?: AssignmentMetadata['population'];
+    activated_at?: string;
+    experiment_group: string;
+    flag_key: string;
+    variant: 'control' | 'treatment';
+    session_id: string;
+    exposure_id: string;
+}
+type ExperimentState<T extends ExperimentConfig = ExperimentConfig> = {
+    status: 'inactive';
+} | {
+    status: 'unavailable';
+    reason: 'disabled' | 'no-session' | 'provider' | 'evaluation' | 'invalid-value' | 'disposed';
+} | {
+    status: 'excluded';
+    variant: 'excluded';
+    config?: Readonly<T>;
+} | {
+    status: 'active';
+    variant: 'control' | 'treatment';
+    assignment: Readonly<Assignment>;
+    config?: Readonly<T>;
+};
+interface Experiment<T extends ExperimentConfig = ExperimentConfig> {
+    readonly id: string;
+    activate: (options?: {
+        signal?: AbortSignal;
+        entryId?: string;
+    }) => Promise<ExperimentState<T>>;
+    getSnapshot: () => ExperimentState<T>;
+    subscribe: (listener: () => void) => () => void;
+}
+/** Attribution captured once for an outcome, independent of destination serialization. */
+interface MeasurementContext {
+    readonly event_id: string;
+    readonly experiments: readonly Readonly<Assignment>[];
+    readonly telemetry_schema_version: 2;
+    readonly event_schema_version?: number;
+    readonly journey_id?: string;
+}
+interface ExperimentsOptions {
+    /** Stable application identifier; namespaces session storage and exposure identities. */
+    scope: string;
+    client: Client;
+    /** Optional existing analytics destination. Omit for Faro-only reporting. */
+    reportAnalytics?: AnalyticsReporter;
+    faro: {
+        instance: Faro;
+        config?: never;
+    } | {
+        config: BrowserConfig;
+        instance?: never;
+    };
+    getSessionId?: () => string | undefined;
+    contextKey?: string;
+    /** Gate both destinations and activation; the host owns consent. */
+    isEnabled?: () => boolean;
+    events?: Record<string, FaroEventType>;
+    eventDefinitions?: Record<string, EventDefinition>;
+    onDiagnostic?: (diagnostic: Diagnostic) => void;
+    enrichFaro?: boolean;
+    transformFaroProperties?: (name: string, properties: Properties) => Properties | null;
+    reportExposure?: (assignment: Readonly<Assignment>) => void | Promise<void>;
+    /**
+     * Opt-in: also send outcome events to the OpenFeature Tracking API, for providers that attribute goals themselves. Return the details to send, or
+     * null to skip. Receives isolated original properties and captured attribution; return only fields to share. Providers without `track` no-op.
+     */
+    openFeatureTracking?: (name: string, properties: Properties, context: MeasurementContext) => TrackingEventDetails | null | undefined;
+    /**
+     * Record `feature_flag.result.value` on exposures when the provider supplies no variant, as the
+     * OpenTelemetry convention requires. Disable when flag values are sensitive or large. Default true.
+     */
+    recordFlagValue?: boolean;
+    onError?: (error: unknown) => void;
+    readinessTimeoutMs?: number;
+    storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'> | null;
+}
+interface Experiments {
+    readonly ready: Promise<void>;
+    defineExperiment: <T extends ExperimentConfig = ExperimentConfig>(definition: ExperimentDefinition<T>) => Experiment<T>;
+    reportAnalytics: (name: string, properties?: Properties, options?: ReportOptions) => void;
+    /** Call when a host-provided session ID or consent changes. Faro session changes are observed automatically. */
+    refreshSession: () => void;
+    /** Supply a stable, non-secret identity/tenant context key before activating in a new context. */
+    resetContext: (contextKey: string) => void;
+    beginJourney: () => Journey;
+    getEventManifest: () => EventManifest;
+    getDiagnostics: () => readonly Diagnostic[];
+    subscribeDiagnostics: (listener: (diagnostic: Diagnostic) => void) => () => void;
+    /** Attribution snapshot for an opt-in Faro enrichment hook. Never activates experiments. */
+    getActiveAssignments: () => readonly Assignment[];
+    dispose: () => void;
+}
+interface AllocationUnit {
+    type: 'stack' | 'organization' | 'user' | 'session';
+    id: string;
+}
+interface AssignmentMetadata {
+    revision?: string;
+    allocationUnit?: AllocationUnit;
+    population?: 'randomized' | 'test' | 'targeted';
+}
+interface Diagnostic {
+    sequence: number;
+    timestamp: string;
+    code: string;
+    experimentId?: string;
+    eventName?: string;
+    detail?: string;
+}
+type PropertyType = 'string' | 'number' | 'boolean';
+interface EventDefinition {
+    version: number;
+    description?: string;
+    properties: Record<string, {
+        type: PropertyType;
+        required?: boolean;
+    }>;
+}
+interface EventManifest {
+    schemaVersion: 2;
+    scope: string;
+    events: Record<string, EventDefinition>;
+}
+interface Journey {
+    readonly id: string;
+    getTelemetryContext: () => Record<string, string>;
+    reportAnalytics(name: string, properties?: Properties, options?: ReportOptions): void;
+    end(): void;
+}
+
+export type { Assignment as A, Diagnostic as D, ExperimentsOptions as E, FaroEventType as F, Journey as J, MeasurementContext as M, Properties as P, ReportOptions as R, Variant as V, ExperimentConfig as a, ExperimentDefinition as b, Experiment as c, EventManifest as d, Experiments as e, EventDefinition as f, AllocationUnit as g, AnalyticsReporter as h, AssignmentMetadata as i, ExperimentState as j };

package/dist/types-M9Kqiiqw.d.ts

@@ -0,0 +1,171 @@
+import { Faro, BrowserConfig } from '@grafana/faro-web-sdk';
+import { Client, TrackingEventDetails } from '@openfeature/web-sdk';
+
+type Variant = 'control' | 'treatment' | 'excluded';
+type Properties = Record<string, unknown>;
+type AnalyticsReporter = (name: string, properties: Properties) => void | Promise<void>;
+type FaroEventType = 'custom-event' | 'user-action';
+interface ReportOptions {
+    faro?: {
+        type: FaroEventType;
+    };
+}
+interface ExperimentConfig {
+    variant: Variant;
+}
+interface ExperimentDefinition<T extends ExperimentConfig = ExperimentConfig> {
+    id: string;
+    flagKey: string;
+    group?: string;
+    metadata?: AssignmentMetadata;
+    mapAssignment?: (evaluation: {
+        value: unknown;
+        variant?: string;
+        flagMetadata?: Record<string, unknown>;
+        reason?: string;
+    }) => AssignmentMetadata;
+    flag: {
+        type: 'boolean';
+    } | {
+        type: 'object';
+        validate: (value: unknown) => value is T;
+    };
+}
+interface Assignment {
+    experiment_id: string;
+    experiment_revision?: string;
+    allocation_unit_type?: AllocationUnit['type'];
+    allocation_unit_id?: string;
+    assignment_source?: 'provider' | 'host' | 'unknown';
+    population?: AssignmentMetadata['population'];
+    activated_at?: string;
+    experiment_group: string;
+    flag_key: string;
+    variant: 'control' | 'treatment';
+    session_id: string;
+    exposure_id: string;
+}
+type ExperimentState<T extends ExperimentConfig = ExperimentConfig> = {
+    status: 'inactive';
+} | {
+    status: 'unavailable';
+    reason: 'disabled' | 'no-session' | 'provider' | 'evaluation' | 'invalid-value' | 'disposed';
+} | {
+    status: 'excluded';
+    variant: 'excluded';
+    config?: Readonly<T>;
+} | {
+    status: 'active';
+    variant: 'control' | 'treatment';
+    assignment: Readonly<Assignment>;
+    config?: Readonly<T>;
+};
+interface Experiment<T extends ExperimentConfig = ExperimentConfig> {
+    readonly id: string;
+    activate: (options?: {
+        signal?: AbortSignal;
+        entryId?: string;
+    }) => Promise<ExperimentState<T>>;
+    getSnapshot: () => ExperimentState<T>;
+    subscribe: (listener: () => void) => () => void;
+}
+/** Attribution captured once for an outcome, independent of destination serialization. */
+interface MeasurementContext {
+    readonly event_id: string;
+    readonly experiments: readonly Readonly<Assignment>[];
+    readonly telemetry_schema_version: 2;
+    readonly event_schema_version?: number;
+    readonly journey_id?: string;
+}
+interface ExperimentsOptions {
+    /** Stable application identifier; namespaces session storage and exposure identities. */
+    scope: string;
+    client: Client;
+    /** Optional existing analytics destination. Omit for Faro-only reporting. */
+    reportAnalytics?: AnalyticsReporter;
+    faro: {
+        instance: Faro;
+        config?: never;
+    } | {
+        config: BrowserConfig;
+        instance?: never;
+    };
+    getSessionId?: () => string | undefined;
+    contextKey?: string;
+    /** Gate both destinations and activation; the host owns consent. */
+    isEnabled?: () => boolean;
+    events?: Record<string, FaroEventType>;
+    eventDefinitions?: Record<string, EventDefinition>;
+    onDiagnostic?: (diagnostic: Diagnostic) => void;
+    enrichFaro?: boolean;
+    transformFaroProperties?: (name: string, properties: Properties) => Properties | null;
+    reportExposure?: (assignment: Readonly<Assignment>) => void | Promise<void>;
+    /**
+     * Opt-in: also send outcome events to the OpenFeature Tracking API, for providers that attribute goals themselves. Return the details to send, or
+     * null to skip. Receives isolated original properties and captured attribution; return only fields to share. Providers without `track` no-op.
+     */
+    openFeatureTracking?: (name: string, properties: Properties, context: MeasurementContext) => TrackingEventDetails | null | undefined;
+    /**
+     * Record `feature_flag.result.value` on exposures when the provider supplies no variant, as the
+     * OpenTelemetry convention requires. Disable when flag values are sensitive or large. Default true.
+     */
+    recordFlagValue?: boolean;
+    onError?: (error: unknown) => void;
+    readinessTimeoutMs?: number;
+    storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'> | null;
+}
+interface Experiments {
+    readonly ready: Promise<void>;
+    defineExperiment: <T extends ExperimentConfig = ExperimentConfig>(definition: ExperimentDefinition<T>) => Experiment<T>;
+    reportAnalytics: (name: string, properties?: Properties, options?: ReportOptions) => void;
+    /** Call when a host-provided session ID or consent changes. Faro session changes are observed automatically. */
+    refreshSession: () => void;
+    /** Supply a stable, non-secret identity/tenant context key before activating in a new context. */
+    resetContext: (contextKey: string) => void;
+    beginJourney: () => Journey;
+    getEventManifest: () => EventManifest;
+    getDiagnostics: () => readonly Diagnostic[];
+    subscribeDiagnostics: (listener: (diagnostic: Diagnostic) => void) => () => void;
+    /** Attribution snapshot for an opt-in Faro enrichment hook. Never activates experiments. */
+    getActiveAssignments: () => readonly Assignment[];
+    dispose: () => void;
+}
+interface AllocationUnit {
+    type: 'stack' | 'organization' | 'user' | 'session';
+    id: string;
+}
+interface AssignmentMetadata {
+    revision?: string;
+    allocationUnit?: AllocationUnit;
+    population?: 'randomized' | 'test' | 'targeted';
+}
+interface Diagnostic {
+    sequence: number;
+    timestamp: string;
+    code: string;
+    experimentId?: string;
+    eventName?: string;
+    detail?: string;
+}
+type PropertyType = 'string' | 'number' | 'boolean';
+interface EventDefinition {
+    version: number;
+    description?: string;
+    properties: Record<string, {
+        type: PropertyType;
+        required?: boolean;
+    }>;
+}
+interface EventManifest {
+    schemaVersion: 2;
+    scope: string;
+    events: Record<string, EventDefinition>;
+}
+interface Journey {
+    readonly id: string;
+    getTelemetryContext: () => Record<string, string>;
+    reportAnalytics(name: string, properties?: Properties, options?: ReportOptions): void;
+    end(): void;
+}
+
+export type { Assignment as A, Diagnostic as D, ExperimentsOptions as E, FaroEventType as F, Journey as J, MeasurementContext as M, Properties as P, ReportOptions as R, Variant as V, ExperimentConfig as a, ExperimentDefinition as b, Experiment as c, EventManifest as d, Experiments as e, EventDefinition as f, AllocationUnit as g, AnalyticsReporter as h, AssignmentMetadata as i, ExperimentState as j };

package/package.json

@@ -1 +1,73 @@
-{"name":"@grafana-experiments/sdk","version":"0.0.0","license":"Apache-2.0","description":"Bootstrap placeholder for trusted publishing; use a later release."}
+{
+  "name": "@grafana-experiments/sdk",
+  "version": "0.1.0",
+  "description": "Explicit experiment activation and analytics reporting with OpenFeature and Grafana Faro",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "RELEASING.md"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./grafana": {
+      "import": {
+        "types": "./dist/grafana.d.ts",
+        "default": "./dist/grafana.js"
+      },
+      "require": {
+        "types": "./dist/grafana.d.cts",
+        "default": "./dist/grafana.cjs"
+      }
+    },
+    "./react": {
+      "import": {
+        "types": "./dist/react.d.ts",
+        "default": "./dist/react.js"
+      },
+      "require": {
+        "types": "./dist/react.d.cts",
+        "default": "./dist/react.cjs"
+      }
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "@grafana/faro-web-sdk": ">=2.12.0 <2.13.0",
+    "@grafana/runtime": ">=13.2.2 <14",
+    "@openfeature/web-sdk": ">=1.9.0 <2",
+    "react": "^18.3.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@grafana/runtime": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grafana/grafana-experiments-app.git",
+    "directory": "packages/grafana-experiments"
+  },
+  "gitHead": "ba9348e954f7dc3beddba187e56916139bb76790"
+}