@base44-preview/sdk 0.8.48-pr.276.5321860 → 0.8.48-pr.280.7eec9ba

package/dist/client.js

@@ -14,6 +14,9 @@ import { createAppModule } from "./modules/app.js";
 import { createUsersModule } from "./modules/users.js";
 import { RoomsSocket } from "./utils/socket-utils.js";
 import { createAnalyticsModule } from "./modules/analytics.js";
+import { createExperimentsModule } from "./modules/experiments.js";
+import { createExposureTracker } from "./modules/experiment-exposures.js";
+import { EXPERIMENTS_CONTEXT_HEADER, getBrowserExperimentsContext, readExperimentsContext } from "./modules/experiments-context.js";
 import { createActorsModule, resolveActorsHost, } from "./modules/actors.js";
 /**
  * Creates a Base44 client.
@@ -53,10 +56,11 @@ import { createActorsModule, resolveActorsHost, } from "./modules/actors.js";
  * ```
  */
 export function createClient(config) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g;
     const { serverUrl = "https://base44.app", appId, analytics, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, } = config;
     // Normalize appBaseUrl to always be a string (empty if not provided or invalid)
     const normalizedAppBaseUrl = typeof appBaseUrl === "string" ? appBaseUrl : "";
+    const experimentsContext = (_a = config.experiments) !== null && _a !== void 0 ? _a : getBrowserExperimentsContext(appId);
     const socketConfig = {
         serverUrl,
         mountPath: "/ws-user-apps/socket.io/",
@@ -73,9 +77,14 @@ export function createClient(config) {
         }
         return socket;
     };
+    const { [EXPERIMENTS_CONTEXT_HEADER]: inheritedExperimentsContext, ...requestHeaders } = optionalHeaders !== null && optionalHeaders !== void 0 ? optionalHeaders : {};
     const headers = {
-        ...optionalHeaders,
+        ...requestHeaders,
         "X-App-Id": String(appId),
+        ...(experimentsContext ? {
+            "Base44-Visitor-Id": experimentsContext.identity.visitorId,
+            "Base44-Experiment-Preview": JSON.stringify((_b = experimentsContext.preview) !== null && _b !== void 0 ? _b : {}),
+        } : {}),
     };
     const functionHeaders = functionsVersion
         ? {
@@ -121,10 +130,24 @@ export function createClient(config) {
         baseURL: `${serverUrl}/api`,
         headers,
     });
+    const exposureTracker = createExposureTracker({
+        axiosClient,
+        appId,
+        enabled: (_c = analytics === null || analytics === void 0 ? void 0 : analytics.enabled) !== null && _c !== void 0 ? _c : true,
+        source: typeof window === "undefined" ? "backend" : "browser",
+        pageUrl: experimentsContext === null || experimentsContext === void 0 ? void 0 : experimentsContext.pageUrl,
+    });
+    const experiments = createExperimentsModule({
+        getAuth: () => userAuthModule,
+        trackExposure: exposureTracker.track,
+        flushExposures: exposureTracker.flush,
+        context: experimentsContext,
+    });
     const userAuthModule = createAuthModule(axiosClient, functionsAxiosClient, appId, {
         appBaseUrl: normalizedAppBaseUrl,
         serverUrl,
         token,
+        onAuthStateChange: experiments.onAuthStateChange,
     });
     // Apply the access token before any module that may issue authenticated
     // requests during construction (notably analytics, which fires an init
@@ -136,11 +159,19 @@ export function createClient(config) {
             userAuthModule.setToken(accessToken);
         }
     }
+    if (experimentsContext) {
+        const { userId, status } = experimentsContext.identity;
+        // The document's cookie identity may differ from this client's localStorage token.
+        const needsClientIdentity = typeof window !== "undefined" && userAuthModule.hasToken() &&
+            experimentsContext.config.experiments.some((experiment) => experiment.assign_by === "user");
+        experiments.onAuthStateChange(status === "pending" || needsClientIdentity ? { status: "pending" } :
+            userId ? { status: "authenticated", userId } : { status: "anonymous" });
+    }
     const actorsModule = createActorsModule({
         appId,
         // serverUrl is often relative/empty (same-origin app); the proxy-fallback
         // URL needs an absolute host, so fall back to the page origin.
-        host: resolveActorsHost(serverUrl, typeof window !== "undefined" ? (_a = window.location) === null || _a === void 0 ? void 0 : _a.origin : undefined),
+        host: resolveActorsHost(serverUrl, typeof window !== "undefined" ? (_d = window.location) === null || _d === void 0 ? void 0 : _d.origin : undefined),
         functionsVersion,
         getAuthToken: () => token || getAccessToken(),
         mintConnectionToken: async (actorName, room, connectionId) => {
@@ -168,6 +199,7 @@ export function createClient(config) {
         integrations: createIntegrationsModule(axiosClient, appId),
         connectors: createUserConnectorsModule(axiosClient, appId),
         auth: userAuthModule,
+        experiments: experiments.module,
         functions: createFunctionsModule(functionsAxiosClient, appId, {
             getAuthHeaders: () => {
                 const headers = {};
@@ -178,7 +210,7 @@ export function createClient(config) {
                 }
                 return headers;
             },
-            baseURL: (_b = functionsAxiosClient.defaults) === null || _b === void 0 ? void 0 : _b.baseURL,
+            baseURL: (_e = functionsAxiosClient.defaults) === null || _e === void 0 ? void 0 : _e.baseURL,
         }),
         agents: createAgentsModule({
             axios: axiosClient,
@@ -196,11 +228,14 @@ export function createClient(config) {
             serverUrl,
             appId,
             userAuthModule,
-            enabled: (_c = analytics === null || analytics === void 0 ? void 0 : analytics.enabled) !== null && _c !== void 0 ? _c : true,
+            enabled: (_f = analytics === null || analytics === void 0 ? void 0 : analytics.enabled) !== null && _f !== void 0 ? _f : true,
+            getVisitorId: experiments.visitorId,
+            experimentsContext,
         }),
         actors: actorsModule.module,
         cleanup: () => {
             userModules.analytics.cleanup();
+            experiments.cleanup();
             actorsModule.closeAll();
             if (socket) {
                 socket.disconnect();
@@ -225,7 +260,7 @@ export function createClient(config) {
                 }
                 return headers;
             },
-            baseURL: (_d = serviceRoleFunctionsAxiosClient.defaults) === null || _d === void 0 ? void 0 : _d.baseURL,
+            baseURL: (_g = serviceRoleFunctionsAxiosClient.defaults) === null || _g === void 0 ? void 0 : _g.baseURL,
         }),
         agents: createAgentsModule({
             axios: serviceRoleAxiosClient,
@@ -268,7 +303,10 @@ export function createClient(config) {
             appId: String(appId),
             serverUrl,
             functionsVersion,
-            platformHeaders: optionalHeaders,
+            platformHeaders: {
+                ...headers,
+                ...(inheritedExperimentsContext ? { [EXPERIMENTS_CONTEXT_HEADER]: inheritedExperimentsContext } : {}),
+            },
         }),
         /**
          * Sets a new authentication token for all subsequent requests.
@@ -420,6 +458,10 @@ export function createClientFromRequest(request) {
     }
     // Prepare additional headers to propagate
     const additionalHeaders = {};
+    const encodedExperiments = request.headers.get(EXPERIMENTS_CONTEXT_HEADER);
+    const experimentsContext = readExperimentsContext(encodedExperiments, appId);
+    if (experimentsContext && encodedExperiments)
+        additionalHeaders[EXPERIMENTS_CONTEXT_HEADER] = encodedExperiments;
     if (stateHeader) {
         additionalHeaders["Base44-State"] = stateHeader;
     }
@@ -440,5 +482,6 @@ export function createClientFromRequest(request) {
         serviceToken: serviceRoleToken,
         functionsVersion: functionsVersion !== null && functionsVersion !== void 0 ? functionsVersion : undefined,
         headers: additionalHeaders,
+        experiments: experimentsContext ? { ...experimentsContext, pageUrl: request.url ? new URL(request.url).pathname : "/" } : undefined,
     });
 }

package/dist/client.types.d.ts

@@ -9,6 +9,8 @@ import type { AiGatewayModule } from "./modules/ai-gateway.types.js";
 import type { AppLogsModule } from "./modules/app-logs.types.js";
 import type { AppModule } from "./modules/app.types.js";
 import type { AnalyticsModule } from "./modules/analytics.types.js";
+import type { ExperimentsModule } from "./modules/experiments.types.js";
+import type { ExperimentsContext } from "./modules/experiments-config.types.js";
 import type { ActorsModule } from "./modules/actors.types.js";
 import type { FetchWithAuthInit } from "./utils/fetch-with-auth.js";
 /**
@@ -39,9 +41,9 @@ export interface CreateClientAnalyticsConfig {
     /**
      * Whether app analytics is enabled for this client.
      *
-     * When disabled, automatic analytics and calls to `analytics.track()` are
-     * no-ops. The SDK does not create an analytics session identifier, start
-     * heartbeat timers, or send analytics requests.
+     * When disabled, automatic analytics, experiment exposures and calls to
+     * `analytics.track()` are no-ops. The SDK does not create an analytics session
+     * identifier, start heartbeat timers, or send analytics requests.
      *
      * @defaultValue `true`
      */
@@ -79,6 +81,12 @@ export interface CreateClientConfig {
      * Omit this option to preserve the default analytics behavior.
      */
     analytics?: CreateClientAnalyticsConfig;
+    /**
+     * Platform-validated context for local flag evaluation. Request-scoped on servers.
+     * Automatically read from the platform bootstrap in browsers and trusted headers
+     * by createClientFromRequest(). Not an authorization credential.
+     */
+    experiments?: ExperimentsContext;
     /**
      * User authentication token. Used to authenticate as a specific user.
      *
@@ -134,6 +142,8 @@ export interface Base44Client {
     connectors: UserConnectorsModule;
     /** {@link EntitiesModule | Entities module} for CRUD operations on your data models. */
     entities: EntitiesModule;
+    /** {@link ExperimentsModule | Experiments module} for local feature flags and exposures. */
+    experiments: ExperimentsModule;
     /** {@link FunctionsModule | Functions module} for invoking custom backend functions. */
     functions: FunctionsModule;
     /** {@link IntegrationsModule | Integrations module} for calling pre-built integration endpoints. */

package/dist/index.d.ts

@@ -4,6 +4,9 @@ import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
 export type { Base44Client, CreateClientAnalyticsConfig, CreateClientConfig, CreateClientOptions, Base44ErrorJSON, };
 export * from "./types.js";
+export { evaluateExperiments } from "./modules/experiments-evaluator.js";
+export type { ExperimentsConfig, ExperimentsContext, ExperimentsIdentity } from "./modules/experiments-config.types.js";
+export type { ExperimentsModule, ExperimentsSnapshot, } from "./modules/experiments.types.js";
 export type { DeleteManyResult, DeleteResult, EntitiesModule, EntityFilterOperators, EntityFilterQuery, EntityFilterValue, EntityHandler, EntityRecord, EntityTypeRegistry, ImportResult, RealtimeEventType, RealtimeEvent, RealtimeCallback, SortField, UpdateManyResult, } from "./modules/entities.types.js";
 export type { AuthModule, LoginResponse, RegisterParams, VerifyOtpParams, ChangePasswordParams, ResetPasswordParams, User, } from "./modules/auth.types.js";
 export type { IntegrationsModule, IntegrationEndpointFunction, CoreIntegrations, InvokeLLMParams, GenerateImageParams, GenerateImageResult, UploadFileParams, UploadFileResult, SendEmailParams, SendEmailResult, ExtractDataFromUploadedFileParams, ExtractDataFromUploadedFileResult, UploadPrivateFileParams, UploadPrivateFileResult, CreateFileSignedUrlParams, CreateFileSignedUrlResult, } from "./modules/integrations.types.js";
@@ -18,14 +21,3 @@ export { Actor, type Conn } from "./actor.js";
 export type { ConnectorsModule, UserConnectorsModule, ConnectorApiRequest, ConnectorApiResponse, ConnectorApiResponsePhase, } from "./modules/connectors.types.js";
 export type { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";
 export type { GetAccessTokenOptions, SaveAccessTokenOptions, RemoveAccessTokenOptions, GetLoginUrlOptions, } from "./utils/auth-utils.types.js";
-export type { CreateIapClientOptions, IapInternalOptions, } from "./iap/index.js";
-export type { IapConfig, IapConfiguredProductType, IapModule, IapProductConfig, IapSetupReport, } from "./iap/iap.types.js";
-export type { IapEvent, IapEventHandler, IapEventType, IapExpiryReason, IapRenewReason, IapStartReason, } from "./iap/events/events.types.js";
-export type { EntitlementQuery, Entitlements, IapExpirationReason, IapRevocation, IapSubscriptionOffer, IapSubscriptionStatus, OwnedNonConsumable, OwnedNonRenewingSubscription, SubscriptionQuery, SubscriptionState, TransactionQuery, } from "./iap/read/read.types.js";
-export type { HandleNotificationResult } from "./iap/ingest/notifications.js";
-export type { RecordTransactionOptions, RecordTransactionResult, SyncPayload, SyncResult, } from "./iap/ingest/device.types.js";
-export type { IapConsumptionOutcome, IapConsumptionRequestRecord, IapNotificationOutcome, IapNotificationRecord, IapRecordSource, IapSubscriptionRecord, IapTransactionRecord, } from "./iap/store/rows.types.js";
-export type { IapEntityName, IapEntitySchema, IapSchemaField, } from "./iap/store/schemas.js";
-export type { ConsumptionRequestBody, IapDeliveryStatus, IapRefundPreference, IapServerApiConfig, IapServerApiModule, SendAttempt, SendAttemptResult, TestNotificationResult, TestNotificationStatus, } from "./iap/server-api/server-api.types.js";
-export type { IapApiErrorCode, IapConfigErrorCode, IapSetupErrorCode, IapStoreErrorCode, IapVerificationErrorCode, } from "./iap/errors.types.js";
-export type { DecodedNotification, DecodedNotificationData, DecodedNotificationSummary, DecodedRenewalInfo, DecodedTransaction, IapAppleSubscriptionStatus, IapConsumptionRequestReason, IapEnvironment, IapExpirationIntent, IapOfferDiscountType, IapOfferType, IapOwnershipType, IapProductType, IapRevocationType, IapTransactionReason, } from "./iap/verify/verify.types.js";

package/dist/index.js

@@ -3,4 +3,5 @@ import { Base44Error } from "./utils/axios-client.js";
 import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, } from "./utils/auth-utils.js";
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
 export * from "./types.js";
+export { evaluateExperiments } from "./modules/experiments-evaluator.js";
 export { Actor } from "./actor.js";

package/dist/modules/analytics.d.ts

@@ -1,6 +1,7 @@
 import { AxiosInstance } from "axios";
-import { TrackEventParams, AnalyticsModuleOptions } from "./analytics.types";
+import { TrackEventParams, TrackEventData, AnalyticsModuleOptions, SessionContext } from "./analytics.types";
 import type { InternalAuthModule } from "./auth.types";
+import type { ExperimentsContext } from "./experiments-config.types.js";
 export declare const USER_HEARTBEAT_EVENT_NAME = "__user_heartbeat_event__";
 export declare const ANALYTICS_INITIALIZATION_EVENT_NAME = "__initialization_event__";
 export declare const ANALYTICS_SESSION_DURATION_EVENT_NAME = "__session_duration_event__";
@@ -12,8 +13,22 @@ export interface AnalyticsModuleArgs {
     appId: string;
     userAuthModule: InternalAuthModule;
     enabled: boolean;
+    getVisitorId?: () => string | undefined;
+    experimentsContext?: ExperimentsContext;
 }
-export declare const createAnalyticsModule: ({ axiosClient, serverUrl, appId, userAuthModule, enabled, }: AnalyticsModuleArgs) => {
+/** @internal */
+export declare function isAnalyticsEnabled(enabled: boolean, state?: {
+    requestsQueue: TrackEventData[];
+    isProcessing: boolean;
+    isHeartBeatProcessing: boolean;
+    wasInitializationTracked: boolean;
+    sessionContext: SessionContext | null;
+    sessionContextPromise: Promise<SessionContext> | null;
+    sessionStartTime: string | null;
+    fallbackSessionId: string | null;
+    config: Required<AnalyticsModuleOptions>;
+}): boolean;
+export declare const createAnalyticsModule: ({ axiosClient, serverUrl, appId, userAuthModule, enabled, getVisitorId, experimentsContext, }: AnalyticsModuleArgs) => {
     track: (params: TrackEventParams) => void;
     cleanup: () => void;
 };
@@ -27,6 +42,16 @@ export declare const createAnalyticsModule: ({ axiosClient, serverUrl, appId, us
  *
  * @internal
  */
-export declare function resetAnalyticsSessionContext(): void;
+export declare function resetAnalyticsSessionContext(axiosClient?: AxiosInstance): void;
 export declare function getAnalyticsConfigFromUrlParams(): AnalyticsModuleOptions | undefined;
-export declare function getAnalyticsSessionId(): string;
+export declare function getAnalyticsSessionId(state?: {
+    requestsQueue: TrackEventData[];
+    isProcessing: boolean;
+    isHeartBeatProcessing: boolean;
+    wasInitializationTracked: boolean;
+    sessionContext: SessionContext | null;
+    sessionContextPromise: Promise<SessionContext> | null;
+    sessionStartTime: string | null;
+    fallbackSessionId: string | null;
+    config: Required<AnalyticsModuleOptions>;
+}): string;

package/dist/modules/analytics.js

@@ -1,5 +1,6 @@
 import { getSharedInstance } from "../utils/sharedInstance.js";
 import { generateUuid, isReactNative } from "../utils/common.js";
+import { getExperimentsRuntime } from "./experiments-runtime.types.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__";
@@ -17,31 +18,41 @@ const defaultConfiguration = {
 //// 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(),
-    },
-}));
-export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthModule, enabled, }) => {
-    var _a;
+function createAnalyticsState() {
+    return {
+        requestsQueue: [],
+        isProcessing: false,
+        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 serverAnalyticsStates = new WeakMap();
+/** @internal */
+export function isAnalyticsEnabled(enabled, state = analyticsSharedState) {
+    return enabled && state.config.enabled && !isReactNative;
+}
+export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthModule, enabled, getVisitorId, experimentsContext, }) => {
+    const state = typeof window === "undefined" ? createAnalyticsState() : analyticsSharedState;
+    if (typeof window === "undefined")
+        serverAnalyticsStates.set(axiosClient, state);
     // prevent overflow of events //
-    const { maxQueueSize, throttleTime, batchSize } = analyticsSharedState.config;
+    const { maxQueueSize, throttleTime, batchSize } = 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 (!enabled || !((_a = analyticsSharedState.config) === null || _a === void 0 ? void 0 : _a.enabled) || isReactNative) {
+    if (!isAnalyticsEnabled(enabled, state)) {
         return {
             track: () => { },
             cleanup: () => { },
@@ -70,16 +81,17 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         }
     };
     const flush = async (eventsData, options = {}) => {
+        var _a;
         if (eventsData.length === 0)
             return;
-        const sessionContext_ = await getSessionContext(userAuthModule);
-        const events = eventsData.map(transformEventDataToApiRequestData(sessionContext_));
+        const sessionContext_ = await getSessionContext(userAuthModule, state);
+        const events = eventsData.map(transformEventDataToApiRequestData({ ...sessionContext_, session_id: (_a = getVisitorId === null || getVisitorId === void 0 ? void 0 : getVisitorId()) !== null && _a !== void 0 ? _a : sessionContext_.session_id }));
         try {
             if (!options.isBeacon || !beaconRequest(events)) {
                 await batchRequestFallback(events);
             }
         }
-        catch (_a) {
+        catch (_b) {
             // do nothing
         }
     };
@@ -87,16 +99,25 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         startAnalyticsProcessor(flush, {
             throttleTime,
             batchSize,
-        });
+        }, state);
     };
     const track = (params) => {
-        if (analyticsSharedState.requestsQueue.length >= maxQueueSize) {
+        var _a;
+        if (state.requestsQueue.length >= maxQueueSize) {
             return;
         }
         const intrinsicData = getEventIntrinsicData();
-        analyticsSharedState.requestsQueue.push({
+        const preview = Object.fromEntries(Object.entries((_a = experimentsContext === null || experimentsContext === void 0 ? void 0 : experimentsContext.preview) !== null && _a !== void 0 ? _a : {}).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);
+        }
+        state.requestsQueue.push({
             ...params,
             ...intrinsicData,
+            properties: params.properties || Object.keys(properties).length ? properties : undefined,
         });
         startProcessing();
     };
@@ -104,16 +125,16 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         startAnalyticsProcessor(flush, {
             throttleTime,
             batchSize,
-        });
-        clearHeartBeatProcessor = startHeartBeatProcessor(track);
-        setSessionDurationTimerStart();
+        }, state);
+        clearHeartBeatProcessor = startHeartBeatProcessor(track, state);
+        setSessionDurationTimerStart(state);
     };
     const onDocHidden = () => {
-        stopAnalyticsProcessor();
+        stopAnalyticsProcessor(state);
         clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
-        trackSessionDurationEvent(track);
+        trackSessionDurationEvent(track, state);
         //  flush entire queue on visibility change and hope for the best //
-        const eventsData = analyticsSharedState.requestsQueue.splice(0);
+        const eventsData = state.requestsQueue.splice(0);
         flush(eventsData, { isBeacon: true });
     };
     const onVisibilityChange = () => {
@@ -127,7 +148,7 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         }
     };
     const cleanup = () => {
-        stopAnalyticsProcessor();
+        stopAnalyticsProcessor(state);
         clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
         if (typeof window !== "undefined") {
             window.removeEventListener("visibilitychange", onVisibilityChange);
@@ -136,9 +157,9 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
     // start the flusing process ///
     startProcessing();
     // start the heart beat processor //
-    clearHeartBeatProcessor = startHeartBeatProcessor(track);
+    clearHeartBeatProcessor = startHeartBeatProcessor(track, state);
     // track the referrer event //
-    trackInitializationEvent(track);
+    trackInitializationEvent(track, state);
     // start the visibility change listener //
     if (typeof window !== "undefined") {
         window.addEventListener("visibilitychange", onVisibilityChange);
@@ -148,50 +169,50 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         cleanup,
     };
 };
-function stopAnalyticsProcessor() {
-    analyticsSharedState.isProcessing = false;
+function stopAnalyticsProcessor(state) {
+    state.isProcessing = false;
 }
-async function startAnalyticsProcessor(handleTrack, options) {
-    if (analyticsSharedState.isProcessing) {
+async function startAnalyticsProcessor(handleTrack, options, state) {
+    if (state.isProcessing) {
         // only one instance of the analytics processor can be running at a time //
         return;
     }
-    analyticsSharedState.isProcessing = true;
+    state.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);
+    while (state.isProcessing &&
+        state.requestsQueue.length > 0) {
+        const requests = state.requestsQueue.splice(0, batchSize);
         requests.length && (await handleTrack(requests));
         await new Promise((resolve) => setTimeout(resolve, throttleTime));
     }
-    analyticsSharedState.isProcessing = false;
+    state.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: {
@@ -199,20 +220,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 },
@@ -235,7 +256,6 @@ function transformEventDataToApiRequestData(sessionContext) {
         ...sessionContext,
     });
 }
-let sessionContextPromise = null;
 /**
  * Clears the memoized analytics session context.
  *
@@ -246,22 +266,24 @@ let sessionContextPromise = null;
  *
  * @internal
  */
-export function resetAnalyticsSessionContext() {
-    analyticsSharedState.sessionContext = null;
-    sessionContextPromise = null;
+export function resetAnalyticsSessionContext(axiosClient) {
+    var _a;
+    const state = axiosClient ? (_a = serverAnalyticsStates.get(axiosClient)) !== null && _a !== void 0 ? _a : analyticsSharedState : 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,
@@ -272,7 +294,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
@@ -280,12 +302,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
@@ -307,15 +329,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);
@@ -326,7 +351,7 @@ export function getAnalyticsSessionId() {
         }
         return sessionId;
     }
-    catch (_a) {
-        return getFallbackSessionId();
+    catch (_b) {
+        return getFallbackSessionId(state);
     }
 }