@base44-preview/sdk 0.8.48-pr.280.cc2ee4a → 0.8.48-pr.280.cd0dea6

package/dist/modules/analytics.js

@@ -1,6 +1,7 @@
 import { getSharedInstance } from "../utils/sharedInstance.js";
 import { generateUuid, isReactNative } from "../utils/common.js";
 import { getExperimentsRuntime } from "./experiments-runtime.types.js";
+import { getAnalyticsQueue } from "./analytics-queue.js";
 export const USER_HEARTBEAT_EVENT_NAME = "__user_heartbeat_event__";
 export const ANALYTICS_INITIALIZATION_EVENT_NAME = "__initialization_event__";
 export const ANALYTICS_SESSION_DURATION_EVENT_NAME = "__session_duration_event__";
@@ -14,111 +15,85 @@ const defaultConfiguration = {
     batchSize: 30,
     heartBeatInterval: 60 * 1000,
 };
-///////////////////////////////////////////////
-//// shared queue for analytics events     ////
-///////////////////////////////////////////////
 const ANALYTICS_SHARED_STATE_NAME = "analytics";
-// shared state//
-const analyticsSharedState = getSharedInstance(ANALYTICS_SHARED_STATE_NAME, () => ({
-    requestsQueue: [],
-    isProcessing: false,
-    isHeartBeatProcessing: false,
-    wasInitializationTracked: false,
-    sessionContext: null,
-    sessionStartTime: null,
-    // Memoized session id for when `localStorage` can't persist one — see
-    // getAnalyticsSessionId.
-    fallbackSessionId: null,
-    config: {
-        ...defaultConfiguration,
-        ...getAnalyticsConfigFromUrlParams(),
-    },
-}));
+function createAnalyticsState() {
+    return {
+        isHeartBeatProcessing: false,
+        wasInitializationTracked: false,
+        sessionContext: null,
+        sessionContextPromise: null,
+        sessionStartTime: null,
+        // Memoized session id for when `localStorage` can't persist one — see
+        // getAnalyticsSessionId.
+        fallbackSessionId: null,
+        config: {
+            ...defaultConfiguration,
+            ...getAnalyticsConfigFromUrlParams(),
+        },
+    };
+}
+const analyticsSharedState = getSharedInstance(ANALYTICS_SHARED_STATE_NAME, createAnalyticsState);
+const clientAnalyticsStates = new WeakMap();
 /** @internal */
-export function isAnalyticsEnabled(enabled) {
-    return enabled && analyticsSharedState.config.enabled && !isReactNative;
+export function getAnalyticsState(axiosClient) {
+    let state = clientAnalyticsStates.get(axiosClient);
+    if (!state) {
+        state = createAnalyticsState();
+        if (typeof window !== "undefined") {
+            state.config = analyticsSharedState.config;
+        }
+        clientAnalyticsStates.set(axiosClient, state);
+    }
+    return state;
 }
-export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthModule, enabled, }) => {
-    // prevent overflow of events //
-    const { maxQueueSize, throttleTime, batchSize } = analyticsSharedState.config;
+/** @internal */
+export function isAnalyticsEnabled(enabled, state = analyticsSharedState) {
+    return enabled && state.config.enabled && !isReactNative;
+}
+export const createAnalyticsModule = ({ axiosClient, appId, userAuthModule, enabled, getVisitorId, experimentsContext, }) => {
+    const state = getAnalyticsState(axiosClient);
+    const automaticState = typeof window === "undefined" ? state : analyticsSharedState;
+    const queue = getAnalyticsQueue(axiosClient, appId, state.config);
     // Disable analytics on React Native. It defines `window` but not `document`,
     // so the per-callsite `typeof window` guards below aren't enough to keep it
     // from touching `document` (e.g. `document.referrer` on init). Node/SSR is
     // still handled by those `window` guards, so this doesn't affect it.
-    if (!isAnalyticsEnabled(enabled)) {
+    if (!isAnalyticsEnabled(enabled, state)) {
         return {
             track: () => { },
             cleanup: () => { },
         };
     }
     let clearHeartBeatProcessor = undefined;
-    const trackBatchUrl = `${serverUrl}/api/apps/${appId}/analytics/track/batch`;
-    const batchRequestFallback = async (events) => {
-        await axiosClient.request({
-            method: "POST",
-            url: `/apps/${appId}/analytics/track/batch`,
-            data: { events },
-        });
-    };
-    // currently disabled, until fully tested  //
-    const beaconRequest = (events) => {
-        try {
-            const beaconPayload = JSON.stringify({ events });
-            const blob = new Blob([beaconPayload], { type: "application/json" });
-            return (typeof navigator === "undefined" ||
-                beaconPayload.length > 60000 ||
-                !navigator.sendBeacon(trackBatchUrl, blob));
-        }
-        catch (_a) {
-            return false;
-        }
-    };
-    const flush = async (eventsData, options = {}) => {
-        if (eventsData.length === 0)
-            return;
-        const sessionContext_ = await getSessionContext(userAuthModule);
-        const events = eventsData.map(transformEventDataToApiRequestData(sessionContext_));
-        try {
-            if (!options.isBeacon || !beaconRequest(events)) {
-                await batchRequestFallback(events);
-            }
-        }
-        catch (_a) {
-            // do nothing
-        }
-    };
-    const startProcessing = () => {
-        startAnalyticsProcessor(flush, {
-            throttleTime,
-            batchSize,
-        });
-    };
     const track = (params) => {
-        if (analyticsSharedState.requestsQueue.length >= maxQueueSize) {
-            return;
-        }
+        var _a, _b;
         const intrinsicData = getEventIntrinsicData();
-        analyticsSharedState.requestsQueue.push({
-            ...params,
-            ...intrinsicData,
-        });
-        startProcessing();
+        const visitorId = (_a = getVisitorId === null || getVisitorId === void 0 ? void 0 : getVisitorId()) !== null && _a !== void 0 ? _a : getAnalyticsSessionId(state);
+        const authorization = userAuthModule.hasToken() ? axiosClient.defaults.headers.common.Authorization : null;
+        const context = getSessionContext(userAuthModule, state);
+        const preview = Object.fromEntries(Object.entries((_b = experimentsContext === null || experimentsContext === void 0 ? void 0 : experimentsContext.preview) !== null && _b !== void 0 ? _b : {}).filter(([, value]) => typeof value === "boolean"));
+        const properties = { ...params.properties };
+        delete properties.__b44_experiment_preview;
+        if (Object.keys(preview).length) {
+            // Capture now: a queued event must retain its occurrence-time preview.
+            properties.__b44_experiment_preview = JSON.stringify(preview);
+        }
+        const event = {
+            event_name: params.eventName,
+            timestamp: intrinsicData.timestamp,
+            page_url: intrinsicData.pageUrl,
+            properties: params.properties || Object.keys(properties).length ? properties : undefined,
+        };
+        queue.enqueue(context.then((identity) => ({ ...event, ...identity, session_id: visitorId })), typeof authorization === "string" ? authorization : null, context.then((identity) => { var _a; return (_a = identity.user_id) !== null && _a !== void 0 ? _a : null; }));
     };
     const onDocVisible = () => {
-        startAnalyticsProcessor(flush, {
-            throttleTime,
-            batchSize,
-        });
-        clearHeartBeatProcessor = startHeartBeatProcessor(track);
-        setSessionDurationTimerStart();
+        clearHeartBeatProcessor = startHeartBeatProcessor(track, automaticState);
+        setSessionDurationTimerStart(automaticState);
     };
     const onDocHidden = () => {
-        stopAnalyticsProcessor();
         clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
-        trackSessionDurationEvent(track);
-        //  flush entire queue on visibility change and hope for the best //
-        const eventsData = analyticsSharedState.requestsQueue.splice(0);
-        flush(eventsData, { isBeacon: true });
+        trackSessionDurationEvent(track, automaticState);
+        void queue.flush();
     };
     const onVisibilityChange = () => {
         if (typeof window === "undefined")
@@ -131,18 +106,16 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         }
     };
     const cleanup = () => {
-        stopAnalyticsProcessor();
+        queue.cleanup();
         clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
         if (typeof window !== "undefined") {
             window.removeEventListener("visibilitychange", onVisibilityChange);
         }
     };
-    // start the flusing process ///
-    startProcessing();
     // start the heart beat processor //
-    clearHeartBeatProcessor = startHeartBeatProcessor(track);
+    clearHeartBeatProcessor = startHeartBeatProcessor(track, automaticState);
     // track the referrer event //
-    trackInitializationEvent(track);
+    trackInitializationEvent(track, automaticState);
     // start the visibility change listener //
     if (typeof window !== "undefined") {
         window.addEventListener("visibilitychange", onVisibilityChange);
@@ -152,50 +125,32 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         cleanup,
     };
 };
-function stopAnalyticsProcessor() {
-    analyticsSharedState.isProcessing = false;
-}
-async function startAnalyticsProcessor(handleTrack, options) {
-    if (analyticsSharedState.isProcessing) {
-        // only one instance of the analytics processor can be running at a time //
-        return;
-    }
-    analyticsSharedState.isProcessing = true;
-    const { throttleTime = 1000, batchSize = 30 } = options !== null && options !== void 0 ? options : {};
-    while (analyticsSharedState.isProcessing &&
-        analyticsSharedState.requestsQueue.length > 0) {
-        const requests = analyticsSharedState.requestsQueue.splice(0, batchSize);
-        requests.length && (await handleTrack(requests));
-        await new Promise((resolve) => setTimeout(resolve, throttleTime));
-    }
-    analyticsSharedState.isProcessing = false;
-}
-function startHeartBeatProcessor(track) {
+function startHeartBeatProcessor(track, state) {
     var _a;
     // Browser-only, like the other automatic events here (initialization, session
     // duration, visibility). Outside a browser this timer fired a `me()` every
     // interval for the lifetime of a long-lived server-side client, and kept the
     // Node event loop alive. Explicit `analytics.track()` calls still work.
     if (typeof window === "undefined" ||
-        analyticsSharedState.isHeartBeatProcessing ||
-        ((_a = analyticsSharedState.config.heartBeatInterval) !== null && _a !== void 0 ? _a : 0) < 10) {
+        state.isHeartBeatProcessing ||
+        ((_a = state.config.heartBeatInterval) !== null && _a !== void 0 ? _a : 0) < 10) {
         return () => { };
     }
-    analyticsSharedState.isHeartBeatProcessing = true;
+    state.isHeartBeatProcessing = true;
     const interval = setInterval(() => {
         track({ eventName: USER_HEARTBEAT_EVENT_NAME });
-    }, analyticsSharedState.config.heartBeatInterval);
+    }, state.config.heartBeatInterval);
     return () => {
         clearInterval(interval);
-        analyticsSharedState.isHeartBeatProcessing = false;
+        state.isHeartBeatProcessing = false;
     };
 }
-function trackInitializationEvent(track) {
+function trackInitializationEvent(track, state) {
     if (typeof window === "undefined" ||
-        analyticsSharedState.wasInitializationTracked) {
+        state.wasInitializationTracked) {
         return;
     }
-    analyticsSharedState.wasInitializationTracked = true;
+    state.wasInitializationTracked = true;
     track({
         eventName: ANALYTICS_INITIALIZATION_EVENT_NAME,
         properties: {
@@ -203,20 +158,20 @@ function trackInitializationEvent(track) {
         },
     });
 }
-function setSessionDurationTimerStart() {
+function setSessionDurationTimerStart(state) {
     if (typeof window === "undefined" ||
-        analyticsSharedState.sessionStartTime !== null) {
+        state.sessionStartTime !== null) {
         return;
     }
-    analyticsSharedState.sessionStartTime = new Date().toISOString();
+    state.sessionStartTime = new Date().toISOString();
 }
-function trackSessionDurationEvent(track) {
+function trackSessionDurationEvent(track, state) {
     if (typeof window === "undefined" ||
-        analyticsSharedState.sessionStartTime === null)
+        state.sessionStartTime === null)
         return;
     const sessionDuration = new Date().getTime() -
-        new Date(analyticsSharedState.sessionStartTime).getTime();
-    analyticsSharedState.sessionStartTime = null;
+        new Date(state.sessionStartTime).getTime();
+    state.sessionStartTime = null;
     track({
         eventName: ANALYTICS_SESSION_DURATION_EVENT_NAME,
         properties: { sessionDuration },
@@ -230,16 +185,6 @@ function getEventIntrinsicData() {
         pageUrl: typeof window !== "undefined" ? (_b = (_a = window.location) === null || _a === void 0 ? void 0 : _a.pathname) !== null && _b !== void 0 ? _b : null : null,
     };
 }
-function transformEventDataToApiRequestData(sessionContext) {
-    return (eventData) => ({
-        event_name: eventData.eventName,
-        properties: eventData.properties,
-        timestamp: eventData.timestamp,
-        page_url: eventData.pageUrl,
-        ...sessionContext,
-    });
-}
-let sessionContextPromise = null;
 /**
  * Clears the memoized analytics session context.
  *
@@ -250,22 +195,23 @@ let sessionContextPromise = null;
  *
  * @internal
  */
-export function resetAnalyticsSessionContext() {
-    analyticsSharedState.sessionContext = null;
-    sessionContextPromise = null;
+export function resetAnalyticsSessionContext(axiosClient) {
+    const state = axiosClient ? getAnalyticsState(axiosClient) : analyticsSharedState;
+    state.sessionContext = null;
+    state.sessionContextPromise = null;
 }
-async function getSessionContext(userAuthModule) {
-    if (!analyticsSharedState.sessionContext) {
+async function getSessionContext(userAuthModule, state) {
+    if (!state.sessionContext) {
         // With no token there is no identity to resolve: `me()` can only answer 401,
         // which the browser logs to the console before any handler here sees it. On
         // a public page that request is the sole reason an error appears, so skip
         // it. This is not memoized — a visitor who logs in later must still resolve.
         if (!userAuthModule.hasToken()) {
-            return { user_id: null, session_id: getAnalyticsSessionId() };
+            return { user_id: null, session_id: getAnalyticsSessionId(state) };
         }
-        if (!sessionContextPromise) {
-            const sessionId = getAnalyticsSessionId();
-            sessionContextPromise = userAuthModule
+        if (!state.sessionContextPromise) {
+            const sessionId = getAnalyticsSessionId(state);
+            state.sessionContextPromise = userAuthModule
                 .me()
                 .then((user) => ({
                 user_id: user.id,
@@ -276,7 +222,7 @@ async function getSessionContext(userAuthModule) {
                 session_id: sessionId,
             }));
         }
-        const pending = sessionContextPromise;
+        const pending = state.sessionContextPromise;
         const context = await pending;
         // Publish only if this lookup is still the current one. A reset that lands
         // while the request is in flight nulls `sessionContextPromise`, and an
@@ -284,12 +230,12 @@ async function getSessionContext(userAuthModule) {
         // for the rest of the session. The awaited value is still returned: these
         // events were queued before the identity changed, so that is who they
         // belong to.
-        if (sessionContextPromise === pending) {
-            analyticsSharedState.sessionContext = context;
+        if (state.sessionContextPromise === pending) {
+            state.sessionContext = context;
         }
         return context;
     }
-    return analyticsSharedState.sessionContext;
+    return state.sessionContext;
 }
 export function getAnalyticsConfigFromUrlParams() {
     // `window.location` is absent on React Native. This runs at module load (via
@@ -311,19 +257,18 @@ export function getAnalyticsConfigFromUrlParams() {
     // return the config object //
     return { enabled: analyticsEnable === "true" };
 }
-// When the id can't be persisted (React Native has no `localStorage`), keep
-// it stable for the process instead of minting a fresh one per call.
-function getFallbackSessionId() {
+// Without persistent storage, keep the id stable within this analytics state.
+function getFallbackSessionId(state) {
     var _a;
-    return ((_a = analyticsSharedState.fallbackSessionId) !== null && _a !== void 0 ? _a : (analyticsSharedState.fallbackSessionId = generateUuid()));
+    return ((_a = state.fallbackSessionId) !== null && _a !== void 0 ? _a : (state.fallbackSessionId = generateUuid()));
 }
-export function getAnalyticsSessionId() {
+export function getAnalyticsSessionId(state = analyticsSharedState) {
     var _a;
     const visitorId = (_a = getExperimentsRuntime()) === null || _a === void 0 ? void 0 : _a.visitorId;
     if (visitorId && visitorId !== "anon")
         return visitorId;
     if (typeof window === "undefined") {
-        return getFallbackSessionId();
+        return getFallbackSessionId(state);
     }
     try {
         const sessionId = localStorage.getItem(ANALYTICS_SESSION_ID_LOCAL_STORAGE_KEY);
@@ -335,6 +280,6 @@ export function getAnalyticsSessionId() {
         return sessionId;
     }
     catch (_b) {
-        return getFallbackSessionId();
+        return getFallbackSessionId(state);
     }
 }

package/dist/modules/auth.js

@@ -177,7 +177,7 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
             // Drop identity resolved under the previous session: a `me()` already in
             // flight would otherwise resolve into callers that run after the logout.
             clearPendingMe();
-            resetAnalyticsSessionContext();
+            resetAnalyticsSessionContext(axios);
             hasAccessToken = false;
             notifyAuthState({ status: "anonymous" });
             // Only do the rest if in a browser environment
@@ -207,7 +207,7 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
             // Same reasoning as in `logout`: the identity changes here, so anything
             // resolved for the previous one must not be handed to later callers.
             clearPendingMe();
-            resetAnalyticsSessionContext();
+            resetAnalyticsSessionContext(axios);
             hasAccessToken = true;
             // handle token change for axios clients
             axios.defaults.headers.common["Authorization"] = `Bearer ${token}`;
@@ -239,6 +239,8 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
                 const { access_token, user } = response;
                 if (access_token) {
                     this.setToken(access_token);
+                    if (typeof (user === null || user === void 0 ? void 0 : user.id) === "string")
+                        notifyAuthState({ status: "authenticated", userId: user.id });
                 }
                 return {
                     access_token,

package/dist/modules/experiment-exposures.d.ts

@@ -1,9 +1,11 @@
 import type { AxiosInstance } from "axios";
 /** @internal */
-export declare function createExposureTracker({ axiosClient, appId, enabled, }: {
+export declare function createExposureTracker({ axiosClient, appId, enabled, source, pageUrl, }: {
     axiosClient: AxiosInstance;
     appId: string;
     enabled: boolean;
+    source?: "browser" | "backend";
+    pageUrl?: string;
 }): {
     track(assignment: {
         experiment_id: string;
@@ -13,4 +15,5 @@ export declare function createExposureTracker({ axiosClient, appId, enabled, }:
         visitorId: string;
         userId: string | null;
     }): void;
+    flush: () => Promise<void>;
 };

package/dist/modules/experiment-exposures.js

@@ -1,45 +1,30 @@
-import { isAnalyticsEnabled } from "./analytics.js";
+import { v4 as uuid } from "uuid";
+import { getAnalyticsState, isAnalyticsEnabled } from "./analytics.js";
+import { getAnalyticsQueue } from "./analytics-queue.js";
 /** @internal */
-export function createExposureTracker({ axiosClient, appId, enabled, }) {
-    const exposed = new Set();
+export function createExposureTracker({ axiosClient, appId, enabled, source = "browser", pageUrl, }) {
+    const state = getAnalyticsState(axiosClient);
+    const queue = getAnalyticsQueue(axiosClient, appId, state.config);
+    const tracked = new Set();
     return {
         track(assignment, identity) {
-            var _a;
-            if (typeof window === "undefined" || !isAnalyticsEnabled(enabled))
+            if ((source === "browser" && typeof window === "undefined") || !isAnalyticsEnabled(enabled, state))
                 return;
             const { experiment_id, run_version, variant_key } = assignment;
-            const key = JSON.stringify([
-                experiment_id,
-                run_version,
-                variant_key,
-                identity.userId,
-                identity.visitorId,
-            ]);
-            if (exposed.has(key))
+            const key = JSON.stringify([experiment_id, run_version, variant_key, identity.userId, identity.visitorId]);
+            if (tracked.has(key))
                 return;
-            exposed.add(key);
-            // Pin the event's auth before an account change can alter Axios defaults.
-            const authorization = identity.userId
-                ? ((_a = axiosClient.defaults.headers.common.Authorization) !== null && _a !== void 0 ? _a : null)
-                : null;
-            void axiosClient
-                .request({
-                method: "POST",
-                url: `/apps/${appId}/analytics/track/batch`,
-                headers: { Authorization: authorization },
-                data: {
-                    events: [
-                        {
-                            event_name: "__experiment_exposure__",
-                            timestamp: new Date().toISOString(),
-                            session_id: identity.visitorId,
-                            page_url: window.location.pathname,
-                            properties: { experiment_id, run_version, variant_key },
-                        },
-                    ],
-                },
-            })
-                .catch(() => exposed.delete(key));
+            tracked.add(key);
+            const authorization = identity.userId ? axiosClient.defaults.headers.common.Authorization : null;
+            queue.enqueue({
+                event_id: uuid(),
+                event_name: "__experiment_exposure__",
+                timestamp: new Date().toISOString(),
+                session_id: identity.visitorId,
+                page_url: pageUrl !== null && pageUrl !== void 0 ? pageUrl : (typeof window === "undefined" ? "/" : window.location.pathname),
+                properties: { experiment_id, run_version, variant_key, source },
+            }, typeof authorization === "string" ? authorization : null, identity.userId);
         },
+        flush: queue.flush,
     };
 }

package/dist/modules/experiments-config.types.d.ts

@@ -0,0 +1,39 @@
+import type { ExperimentsSnapshot } from "./experiments.types.js";
+/** Shared versioned configuration published by the platform, never visitor-specific. */
+export interface ExperimentsConfig {
+    v: 1;
+    app_id: string;
+    revision?: number;
+    flags: {
+        key: string;
+        rollout_percentage: number;
+    }[];
+    experiments: {
+        id: string;
+        flag_key: string;
+        run_version: number;
+        assign_by: "visitor" | "user";
+        traffic_allocation: number;
+        variants: {
+            key: string;
+            value: boolean;
+            weight: number;
+        }[];
+    }[];
+}
+/** Identity supplied by the platform's normal authenticated request/bootstrap path. */
+export interface ExperimentsIdentity {
+    visitorId: string;
+    userId: string | null;
+    status?: "authenticated" | "anonymous" | "pending";
+}
+/** One request's or browser page's context. Never share it between server requests. */
+export interface ExperimentsContext {
+    config: ExperimentsConfig;
+    identity: ExperimentsIdentity;
+    preview?: Readonly<Record<string, boolean>>;
+    /** Request pathname used for server-side exposure events. */
+    pageUrl?: string;
+    /** Exact server-rendered flags, retained for the browser's first hydration render. */
+    serverSnapshot?: ExperimentsSnapshot;
+}

package/dist/modules/experiments-config.types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/experiments-context.d.ts

@@ -0,0 +1,10 @@
+import type { ExperimentsContext } from "./experiments-config.types.js";
+import type { ExperimentsRuntime } from "./experiments-runtime.types.js";
+/** @internal Platform ingress overwrites this header; it is not authentication. */
+export declare const EXPERIMENTS_CONTEXT_HEADER = "Base44-Experiments-Context";
+/** @internal */
+export declare function readExperimentsContext(encoded: string | null, appId: string): ExperimentsContext | undefined;
+/** @internal */
+export declare function getBrowserExperimentsContext(appId: string): ExperimentsContext | undefined;
+/** One independent evaluator instance for one client/request. @internal */
+export declare function createExperimentsRuntime(context: ExperimentsContext): ExperimentsRuntime;

package/dist/modules/experiments-context.js

@@ -0,0 +1,44 @@
+import { evaluateExperiments } from "./experiments-evaluator.js";
+/** @internal Platform ingress overwrites this header; it is not authentication. */
+export const EXPERIMENTS_CONTEXT_HEADER = "Base44-Experiments-Context";
+/** @internal */
+export function readExperimentsContext(encoded, appId) {
+    if (!encoded || encoded.length > 96 * 1024)
+        return;
+    try {
+        const bytes = Uint8Array.from(atob(encoded.replace(/-/g, "+").replace(/_/g, "/")), (character) => character.charCodeAt(0));
+        return matchingContext(JSON.parse(new TextDecoder().decode(bytes)), appId);
+    }
+    catch (_a) {
+        return;
+    }
+}
+function matchingContext(value, appId) {
+    var _a, _b;
+    return ((_a = value === null || value === void 0 ? void 0 : value.config) === null || _a === void 0 ? void 0 : _a.v) === 1 && value.config.app_id === appId &&
+        typeof ((_b = value.identity) === null || _b === void 0 ? void 0 : _b.visitorId) === "string" && value.identity.visitorId &&
+        (value.identity.userId === null || typeof value.identity.userId === "string")
+        ? value : undefined;
+}
+/** @internal */
+export function getBrowserExperimentsContext(appId) {
+    if (typeof window === "undefined" || typeof document === "undefined")
+        return;
+    return matchingContext(window.__B44_EXPERIMENTS_BOOTSTRAP__, appId);
+}
+/** One independent evaluator instance for one client/request. @internal */
+export function createExperimentsRuntime(context) {
+    const identity = { ...context.identity };
+    const evaluate = () => evaluateExperiments(context.config, identity, context.preview);
+    const runtime = {
+        ...evaluate(),
+        visitorId: identity.visitorId,
+        userId: identity.userId,
+        pendingUser: identity.status === "pending",
+        setUser(userId) {
+            identity.userId = userId;
+            Object.assign(runtime, evaluate(), { userId, pendingUser: false });
+        },
+    };
+    return runtime;
+}

package/dist/modules/experiments-evaluator.d.ts

@@ -0,0 +1,11 @@
+import type { ExperimentAssignment } from "./experiments-runtime.types.js";
+import type { ExperimentsConfig, ExperimentsIdentity } from "./experiments-config.types.js";
+/**
+ * Evaluates flags locally without storage, network, clock, or browser globals.
+ * The same config and identity always produce the same assignments.
+ * This controls presentation, never authorization or access to data.
+ */
+export declare function evaluateExperiments(config: ExperimentsConfig, identity: ExperimentsIdentity, preview?: Readonly<Record<string, boolean>>): {
+    flags: Record<string, boolean>;
+    assignments: ExperimentAssignment[];
+};