posthog-js-lite 3.4.2 → 3.5.1

package/lib/{index.cjs.js → index.cjs}

@@ -2,13 +2,17 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var version = "3.5.1";
+
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
     PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
     PostHogPersistedProperty["DistinctId"] = "distinct_id";
     PostHogPersistedProperty["Props"] = "props";
+    PostHogPersistedProperty["FeatureFlagDetails"] = "feature_flag_details";
     PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
     PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
+    PostHogPersistedProperty["BootstrapFeatureFlagDetails"] = "bootstrap_feature_flag_details";
     PostHogPersistedProperty["BootstrapFeatureFlags"] = "bootstrap_feature_flags";
     PostHogPersistedProperty["BootstrapFeatureFlagPayloads"] = "bootstrap_feature_flag_payloads";
     PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
@@ -22,13 +26,285 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
     PostHogPersistedProperty["SessionReplay"] = "session_replay";
     PostHogPersistedProperty["DecideEndpointWasHit"] = "decide_endpoint_was_hit";
-})(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
+    PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
+    PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
+    PostHogPersistedProperty["Surveys"] = "surveys";
+    PostHogPersistedProperty["RemoteConfig"] = "remote_config";
+})(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
+var SurveyPosition;
+(function (SurveyPosition) {
+    SurveyPosition["Left"] = "left";
+    SurveyPosition["Right"] = "right";
+    SurveyPosition["Center"] = "center";
+})(SurveyPosition || (SurveyPosition = {}));
+var SurveyWidgetType;
+(function (SurveyWidgetType) {
+    SurveyWidgetType["Button"] = "button";
+    SurveyWidgetType["Tab"] = "tab";
+    SurveyWidgetType["Selector"] = "selector";
+})(SurveyWidgetType || (SurveyWidgetType = {}));
+var SurveyType;
+(function (SurveyType) {
+    SurveyType["Popover"] = "popover";
+    SurveyType["API"] = "api";
+    SurveyType["Widget"] = "widget";
+})(SurveyType || (SurveyType = {}));
+var SurveyQuestionDescriptionContentType;
+(function (SurveyQuestionDescriptionContentType) {
+    SurveyQuestionDescriptionContentType["Html"] = "html";
+    SurveyQuestionDescriptionContentType["Text"] = "text";
+})(SurveyQuestionDescriptionContentType || (SurveyQuestionDescriptionContentType = {}));
+var SurveyRatingDisplay;
+(function (SurveyRatingDisplay) {
+    SurveyRatingDisplay["Number"] = "number";
+    SurveyRatingDisplay["Emoji"] = "emoji";
+})(SurveyRatingDisplay || (SurveyRatingDisplay = {}));
+var SurveyQuestionType;
+(function (SurveyQuestionType) {
+    SurveyQuestionType["Open"] = "open";
+    SurveyQuestionType["MultipleChoice"] = "multiple_choice";
+    SurveyQuestionType["SingleChoice"] = "single_choice";
+    SurveyQuestionType["Rating"] = "rating";
+    SurveyQuestionType["Link"] = "link";
+})(SurveyQuestionType || (SurveyQuestionType = {}));
+var SurveyQuestionBranchingType;
+(function (SurveyQuestionBranchingType) {
+    SurveyQuestionBranchingType["NextQuestion"] = "next_question";
+    SurveyQuestionBranchingType["End"] = "end";
+    SurveyQuestionBranchingType["ResponseBased"] = "response_based";
+    SurveyQuestionBranchingType["SpecificQuestion"] = "specific_question";
+})(SurveyQuestionBranchingType || (SurveyQuestionBranchingType = {}));
+var SurveyMatchType;
+(function (SurveyMatchType) {
+    SurveyMatchType["Regex"] = "regex";
+    SurveyMatchType["NotRegex"] = "not_regex";
+    SurveyMatchType["Exact"] = "exact";
+    SurveyMatchType["IsNot"] = "is_not";
+    SurveyMatchType["Icontains"] = "icontains";
+    SurveyMatchType["NotIcontains"] = "not_icontains";
+})(SurveyMatchType || (SurveyMatchType = {}));
+/** Sync with plugin-server/src/types.ts */
+var ActionStepStringMatching;
+(function (ActionStepStringMatching) {
+    ActionStepStringMatching["Contains"] = "contains";
+    ActionStepStringMatching["Exact"] = "exact";
+    ActionStepStringMatching["Regex"] = "regex";
+})(ActionStepStringMatching || (ActionStepStringMatching = {}));
 
+const normalizeDecideResponse = (decideResponse) => {
+    if ('flags' in decideResponse) {
+        // Convert v4 format to v3 format
+        const featureFlags = getFlagValuesFromFlags(decideResponse.flags);
+        const featureFlagPayloads = getPayloadsFromFlags(decideResponse.flags);
+        return {
+            ...decideResponse,
+            featureFlags,
+            featureFlagPayloads,
+        };
+    }
+    else {
+        // Convert v3 format to v4 format
+        const featureFlags = decideResponse.featureFlags ?? {};
+        const featureFlagPayloads = Object.fromEntries(Object.entries(decideResponse.featureFlagPayloads || {}).map(([k, v]) => [k, parsePayload(v)]));
+        const flags = Object.fromEntries(Object.entries(featureFlags).map(([key, value]) => [
+            key,
+            getFlagDetailFromFlagAndPayload(key, value, featureFlagPayloads[key]),
+        ]));
+        return {
+            ...decideResponse,
+            featureFlags,
+            featureFlagPayloads,
+            flags,
+        };
+    }
+};
+function getFlagDetailFromFlagAndPayload(key, value, payload) {
+    return {
+        key: key,
+        enabled: typeof value === 'string' ? true : value,
+        variant: typeof value === 'string' ? value : undefined,
+        reason: undefined,
+        metadata: {
+            id: undefined,
+            version: undefined,
+            payload: payload ? JSON.stringify(payload) : undefined,
+            description: undefined,
+        },
+    };
+}
+/**
+ * Get the flag values from the flags v4 response.
+ * @param flags - The flags
+ * @returns The flag values
+ */
+const getFlagValuesFromFlags = (flags) => {
+    return Object.fromEntries(Object.entries(flags ?? {})
+        .map(([key, detail]) => [key, getFeatureFlagValue(detail)])
+        .filter(([, value]) => value !== undefined));
+};
+/**
+ * Get the payloads from the flags v4 response.
+ * @param flags - The flags
+ * @returns The payloads
+ */
+const getPayloadsFromFlags = (flags) => {
+    const safeFlags = flags ?? {};
+    return Object.fromEntries(Object.keys(safeFlags)
+        .filter((flag) => {
+        const details = safeFlags[flag];
+        return details.enabled && details.metadata && details.metadata.payload !== undefined;
+    })
+        .map((flag) => {
+        const payload = safeFlags[flag].metadata?.payload;
+        return [flag, payload ? parsePayload(payload) : undefined];
+    }));
+};
+const getFeatureFlagValue = (detail) => {
+    return detail === undefined ? undefined : detail.variant ?? detail.enabled;
+};
+const parsePayload = (response) => {
+    if (typeof response !== 'string') {
+        return response;
+    }
+    try {
+        return JSON.parse(response);
+    }
+    catch {
+        return response;
+    }
+};
+/**
+ * Get the normalized flag details from the flags and payloads.
+ * This is used to convert things like boostrap and stored feature flags and payloads to the v4 format.
+ * This helps us ensure backwards compatibility.
+ * If a key exists in the featureFlagPayloads that is not in the featureFlags, we treat it as a true feature flag.
+ *
+ * @param featureFlags - The feature flags
+ * @param featureFlagPayloads - The feature flag payloads
+ * @returns The normalized flag details
+ */
+const createDecideResponseFromFlagsAndPayloads = (featureFlags, featureFlagPayloads) => {
+    // If a feature flag payload key is not in the feature flags, we treat it as true feature flag.
+    const allKeys = [...new Set([...Object.keys(featureFlags ?? {}), ...Object.keys(featureFlagPayloads ?? {})])];
+    const enabledFlags = allKeys
+        .filter((flag) => !!featureFlags[flag] || !!featureFlagPayloads[flag])
+        .reduce((res, key) => ((res[key] = featureFlags[key] ?? true), res), {});
+    const flagDetails = {
+        featureFlags: enabledFlags,
+        featureFlagPayloads: featureFlagPayloads ?? {},
+    };
+    return normalizeDecideResponse(flagDetails);
+};
+const updateFlagValue = (flag, value) => {
+    return {
+        ...flag,
+        enabled: getEnabledFromValue(value),
+        variant: getVariantFromValue(value),
+    };
+};
+function getEnabledFromValue(value) {
+    return typeof value === 'string' ? true : value;
+}
+function getVariantFromValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+
+// Rollout constants
+const NEW_FLAGS_ROLLOUT_PERCENTAGE = 1;
+// The fnv1a hashes of the tokens that are explicitly excluded from the rollout
+// see https://github.com/PostHog/posthog-js-lite/blob/main/posthog-core/src/utils.ts#L84
+// are hashed API tokens from our top 10 for each category supported by this SDK.
+const NEW_FLAGS_EXCLUDED_HASHES = new Set([
+    // Node
+    '61be3dd8',
+    '96f6df5f',
+    '8cfdba9b',
+    'bf027177',
+    'e59430a8',
+    '7fa5500b',
+    '569798e9',
+    '04809ff7',
+    '0ebc61a5',
+    '32de7f98',
+    '3beeb69a',
+    '12d34ad9',
+    '733853ec',
+    '0645bb64',
+    '5dcbee21',
+    'b1f95fa3',
+    '2189e408',
+    '82b460c2',
+    '3a8cc979',
+    '29ef8843',
+    '2cdbf767',
+    '38084b54',
+    // React Native
+    '50f9f8de',
+    '41d0df91',
+    '5c236689',
+    'c11aedd3',
+    'ada46672',
+    'f4331ee1',
+    '42fed62a',
+    'c957462c',
+    'd62f705a',
+    // Web (lots of teams per org, hence lots of API tokens)
+    'e0162666',
+    '01b3e5cf',
+    '441cef7f',
+    'bb9cafee',
+    '8f348eb0',
+    'b2553f3a',
+    '97469d7d',
+    '39f21a76',
+    '03706dcc',
+    '27d50569',
+    '307584a7',
+    '6433e92e',
+    '150c7fbb',
+    '49f57f22',
+    '3772f65b',
+    '01eb8256',
+    '3c9e9234',
+    'f853c7f7',
+    'c0ac4b67',
+    'cd609d40',
+    '10ca9b1a',
+    '8a87f11b',
+    '8e8e5216',
+    '1f6b63b3',
+    'db7943dd',
+    '79b7164c',
+    '07f78e33',
+    '2d21b6fd',
+    '952db5ee',
+    'a7d3b43f',
+    '1924dd9c',
+    '84e1b8f6',
+    'dff631b6',
+    'c5aa8a79',
+    'fa133a95',
+    '498a4508',
+    '24748755',
+    '98f3d658',
+    '21bbda67',
+    '7dbfed69',
+    'be3ec24c',
+    'fc80b8e2',
+    '75cc0998',
+]);
+const STRING_FORMAT = 'utf8';
 function assert(truthyValue, message) {
-    if (!truthyValue) {
+    if (!truthyValue || typeof truthyValue !== 'string' || isEmpty(truthyValue)) {
         throw new Error(message);
     }
 }
+function isEmpty(truthyValue) {
+    if (truthyValue.trim().length === 0) {
+        return true;
+    }
+    return false;
+}
 function removeTrailingSlash(url) {
     return url?.replace(/\/+$/, '');
 }
@@ -70,7 +346,31 @@ const isError = (x) => {
     return x instanceof Error;
 };
 function getFetch() {
-    return typeof fetch !== 'undefined' ? fetch : typeof global.fetch !== 'undefined' ? global.fetch : undefined;
+    return typeof fetch !== 'undefined' ? fetch : typeof globalThis.fetch !== 'undefined' ? globalThis.fetch : undefined;
+}
+// FNV-1a hash function
+// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+// I know, I know, I'm rolling my own hash function, but I didn't want to take on
+// a crypto dependency and this is just temporary anyway
+function fnv1a(str) {
+    let hash = 0x811c9dc5; // FNV offset basis
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    // Convert to hex string, padding to 8 chars
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+function isTokenInRollout(token, percentage = 0, excludedHashes) {
+    const tokenHash = fnv1a(token);
+    // Check excluded hashes (we're explicitly including these tokens from the rollout)
+    if (excludedHashes?.has(tokenHash)) {
+        return false;
+    }
+    // Convert hash to int and divide by max value to get number between 0-1
+    const hashInt = parseInt(tokenHash, 16);
+    const hashFloat = hashInt / 0xffffffff;
+    return hashFloat < percentage;
 }
 
 // Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
@@ -935,11 +1235,21 @@ const uuidv7 = () => uuidv7obj().toString();
 const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
 
 class PostHogFetchHttpError extends Error {
-    constructor(response) {
-        super('HTTP error while fetching PostHog: ' + response.status);
+    constructor(response, reqByteLength) {
+        super('HTTP error while fetching PostHog: status=' + response.status + ', reqByteLength=' + reqByteLength);
         this.response = response;
+        this.reqByteLength = reqByteLength;
         this.name = 'PostHogFetchHttpError';
     }
+    get status() {
+        return this.response.status;
+    }
+    get text() {
+        return this.response.text();
+    }
+    get json() {
+        return this.response.json();
+    }
 }
 class PostHogFetchNetworkError extends Error {
     constructor(error) {
@@ -951,9 +1261,26 @@ class PostHogFetchNetworkError extends Error {
         this.name = 'PostHogFetchNetworkError';
     }
 }
+async function logFlushError(err) {
+    if (err instanceof PostHogFetchHttpError) {
+        let text = '';
+        try {
+            text = await err.text;
+        }
+        catch { }
+        console.error(`Error while flushing PostHog: message=${err.message}, response body=${text}`, err);
+    }
+    else {
+        console.error('Error while flushing PostHog', err);
+    }
+    return Promise.resolve();
+}
 function isPostHogFetchError(err) {
     return typeof err === 'object' && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
 }
+function isPostHogFetchContentTooLargeError(err) {
+    return typeof err === 'object' && err instanceof PostHogFetchHttpError && err.status === 413;
+}
 var QuotaLimitedFeature;
 (function (QuotaLimitedFeature) {
     QuotaLimitedFeature["FeatureFlags"] = "feature_flags";
@@ -962,10 +1289,7 @@ var QuotaLimitedFeature;
 class PostHogCoreStateless {
     constructor(apiKey, options) {
         this.flushPromise = null;
-        this.disableGeoip = true;
-        this.historicalMigration = false;
-        this.disabled = false;
-        this.defaultOptIn = true;
+        this.shutdownPromise = null;
         this.pendingPromises = {};
         // internal
         this._events = new SimpleEventEmitter();
@@ -978,8 +1302,10 @@ class PostHogCoreStateless {
         this.maxQueueSize = Math.max(this.flushAt, options?.maxQueueSize ?? 1000);
         this.flushInterval = options?.flushInterval ?? 10000;
         this.captureMode = options?.captureMode || 'json';
+        this.preloadFeatureFlags = options?.preloadFeatureFlags ?? true;
         // If enable is explicitly set to false we override the optout
         this.defaultOptIn = options?.defaultOptIn ?? true;
+        this.disableSurveys = options?.disableSurveys ?? false;
         this._retryOptions = {
             retryCount: options?.fetchRetryCount ?? 3,
             retryDelay: options?.fetchRetryDelay ?? 3000,
@@ -987,6 +1313,7 @@ class PostHogCoreStateless {
         };
         this.requestTimeout = options?.requestTimeout ?? 10000; // 10 seconds
         this.featureFlagsRequestTimeoutMs = options?.featureFlagsRequestTimeoutMs ?? 3000; // 3 seconds
+        this.remoteConfigRequestTimeoutMs = options?.remoteConfigRequestTimeoutMs ?? 3000; // 3 seconds
         this.disableGeoip = options?.disableGeoip ?? true;
         this.disabled = options?.disabled ?? false;
         this.historicalMigration = options?.historicalMigration ?? false;
@@ -1085,12 +1412,26 @@ class PostHogCoreStateless {
             this.enqueue('identify', payload, options);
         });
     }
+    async identifyStatelessImmediate(distinctId, properties, options) {
+        const payload = {
+            ...this.buildPayload({
+                distinct_id: distinctId,
+                event: '$identify',
+                properties,
+            }),
+        };
+        await this.sendImmediate('identify', payload, options);
+    }
     captureStateless(distinctId, event, properties, options) {
         this.wrap(() => {
             const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
             this.enqueue('capture', payload, options);
         });
     }
+    async captureStatelessImmediate(distinctId, event, properties, options) {
+        const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
+        await this.sendImmediate('capture', payload, options);
+    }
     aliasStateless(alias, distinctId, properties, options) {
         this.wrap(() => {
             const payload = this.buildPayload({
@@ -1105,6 +1446,18 @@ class PostHogCoreStateless {
             this.enqueue('alias', payload, options);
         });
     }
+    async aliasStatelessImmediate(alias, distinctId, properties, options) {
+        const payload = this.buildPayload({
+            event: '$create_alias',
+            distinct_id: distinctId,
+            properties: {
+                ...(properties || {}),
+                distinct_id: distinctId,
+                alias,
+            },
+        });
+        await this.sendImmediate('alias', payload, options);
+    }
     /***
      *** GROUPS
      ***/
@@ -1123,12 +1476,39 @@ class PostHogCoreStateless {
             this.enqueue('capture', payload, options);
         });
     }
+    async getRemoteConfig() {
+        await this._initPromise;
+        let host = this.host;
+        if (host === 'https://us.i.posthog.com') {
+            host = 'https://us-assets.i.posthog.com';
+        }
+        else if (host === 'https://eu.i.posthog.com') {
+            host = 'https://eu-assets.i.posthog.com';
+        }
+        const url = `${host}/array/${this.apiKey}/config`;
+        const fetchOptions = {
+            method: 'GET',
+            headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+        };
+        // Don't retry remote config API calls
+        return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.remoteConfigRequestTimeoutMs)
+            .then((response) => response.json())
+            .catch((error) => {
+            this.logMsgIfDebug(() => console.error('Remote config could not be loaded', error));
+            this._events.emit('error', error);
+            return undefined;
+        });
+    }
     /***
      *** FEATURE FLAGS
      ***/
     async getDecide(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
         await this._initPromise;
-        const url = `${this.host}/decide/?v=3`;
+        // Check if the API token is in the new flags rollout
+        // This is a temporary measure to ensure that we can still use the old flags API
+        // while we migrate to the new flags API
+        const useFlags = isTokenInRollout(this.apiKey, NEW_FLAGS_ROLLOUT_PERCENTAGE, NEW_FLAGS_EXCLUDED_HASHES);
+        const url = useFlags ? `${this.host}/flags/?v=2` : `${this.host}/decide/?v=4`;
         const fetchOptions = {
             method: 'POST',
             headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
@@ -1144,6 +1524,7 @@ class PostHogCoreStateless {
         // Don't retry /decide API calls
         return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
             .then((response) => response.json())
+            .then((response) => normalizeDecideResponse(response))
             .catch((error) => {
             this._events.emit('error', error);
             return undefined;
@@ -1151,23 +1532,41 @@ class PostHogCoreStateless {
     }
     async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
         await this._initPromise;
-        const featureFlags = await this.getFeatureFlagsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip);
-        if (!featureFlags) {
+        const flagDetailResponse = await this.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+        if (flagDetailResponse === undefined) {
             // If we haven't loaded flags yet, or errored out, we respond with undefined
-            return undefined;
+            return {
+                response: undefined,
+                requestId: undefined,
+            };
         }
-        let response = featureFlags[key];
-        // `/decide` v3 returns all flags
+        let response = getFeatureFlagValue(flagDetailResponse.response);
         if (response === undefined) {
             // For cases where the flag is unknown, return false
             response = false;
         }
         // If we have flags we either return the value (true or string) or false
-        return response;
+        return {
+            response,
+            requestId: flagDetailResponse.requestId,
+        };
+    }
+    async getFeatureFlagDetailStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        const decideResponse = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
+        if (decideResponse === undefined) {
+            return undefined;
+        }
+        const featureFlags = decideResponse.flags;
+        const flagDetail = featureFlags[key];
+        return {
+            response: flagDetail,
+            requestId: decideResponse.requestId,
+        };
     }
     async getFeatureFlagPayloadStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
         await this._initPromise;
-        const payloads = await this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip);
+        const payloads = await this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
         if (!payloads) {
             return undefined;
         }
@@ -1178,48 +1577,120 @@ class PostHogCoreStateless {
         }
         return response;
     }
-    async getFeatureFlagPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+    async getFeatureFlagPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
         await this._initPromise;
-        const payloads = (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)).payloads;
+        const payloads = (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate)).payloads;
         return payloads;
     }
-    _parsePayload(response) {
-        try {
-            return JSON.parse(response);
-        }
-        catch {
-            return response;
-        }
+    async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+        await this._initPromise;
+        return await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
     }
-    async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+    async getFeatureFlagsAndPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
         await this._initPromise;
-        return (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)).flags;
+        const featureFlagDetails = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
+        if (!featureFlagDetails) {
+            return {
+                flags: undefined,
+                payloads: undefined,
+                requestId: undefined,
+            };
+        }
+        return {
+            flags: featureFlagDetails.featureFlags,
+            payloads: featureFlagDetails.featureFlagPayloads,
+            requestId: featureFlagDetails.requestId,
+        };
     }
-    async getFeatureFlagsAndPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+    async getFeatureFlagDetailsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
         await this._initPromise;
         const extraPayload = {};
         if (disableGeoip ?? this.disableGeoip) {
             extraPayload['geoip_disable'] = true;
         }
+        if (flagKeysToEvaluate) {
+            extraPayload['flag_keys_to_evaluate'] = flagKeysToEvaluate;
+        }
         const decideResponse = await this.getDecide(distinctId, groups, personProperties, groupProperties, extraPayload);
+        if (decideResponse === undefined) {
+            // We probably errored out, so return undefined
+            return undefined;
+        }
+        // if there's an error on the decideResponse, log a console error, but don't throw an error
+        if (decideResponse.errorsWhileComputingFlags) {
+            console.error('[FEATURE FLAGS] Error while computing feature flags, some flags may be missing or incorrect. Learn more at https://posthog.com/docs/feature-flags/best-practices');
+        }
         // Add check for quota limitation on feature flags
-        if (decideResponse?.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
+        if (decideResponse.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
             console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - feature flags unavailable. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
             return {
-                flags: undefined,
-                payloads: undefined,
+                flags: {},
+                featureFlags: {},
+                featureFlagPayloads: {},
+                requestId: decideResponse?.requestId,
             };
         }
-        const flags = decideResponse?.featureFlags;
-        const payloads = decideResponse?.featureFlagPayloads;
-        let parsedPayloads = payloads;
-        if (payloads) {
-            parsedPayloads = Object.fromEntries(Object.entries(payloads).map(([k, v]) => [k, this._parsePayload(v)]));
+        return decideResponse;
+    }
+    /***
+     *** SURVEYS
+     ***/
+    async getSurveysStateless() {
+        await this._initPromise;
+        if (this.disableSurveys === true) {
+            this.logMsgIfDebug(() => console.log('Loading surveys is disabled.'));
+            return [];
         }
-        return {
-            flags,
-            payloads: parsedPayloads,
+        const url = `${this.host}/api/surveys/?token=${this.apiKey}`;
+        const fetchOptions = {
+            method: 'GET',
+            headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
         };
+        const response = await this.fetchWithRetry(url, fetchOptions)
+            .then((response) => {
+            if (response.status !== 200 || !response.json) {
+                const msg = `Surveys API could not be loaded: ${response.status}`;
+                const error = new Error(msg);
+                this.logMsgIfDebug(() => console.error(error));
+                this._events.emit('error', new Error(msg));
+                return undefined;
+            }
+            return response.json();
+        })
+            .catch((error) => {
+            this.logMsgIfDebug(() => console.error('Surveys API could not be loaded', error));
+            this._events.emit('error', error);
+            return undefined;
+        });
+        const newSurveys = response?.surveys;
+        if (newSurveys) {
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Surveys fetched from API: ', JSON.stringify(newSurveys)));
+        }
+        return newSurveys ?? [];
+    }
+    get props() {
+        if (!this._props) {
+            this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
+        }
+        return this._props || {};
+    }
+    set props(val) {
+        this._props = val;
+    }
+    async register(properties) {
+        this.wrap(() => {
+            this.props = {
+                ...this.props,
+                ...properties,
+            };
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
+    }
+    async unregister(property) {
+        this.wrap(() => {
+            delete this.props[property];
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
     }
     /***
      *** QUEUEING AND FLUSHING
@@ -1230,25 +1701,7 @@ class PostHogCoreStateless {
                 this._events.emit(type, `Library is disabled. Not sending event. To re-enable, call posthog.optIn()`);
                 return;
             }
-            const message = {
-                ..._message,
-                type: type,
-                library: this.getLibraryId(),
-                library_version: this.getLibraryVersion(),
-                timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
-                uuid: options?.uuid ? options.uuid : uuidv7(),
-            };
-            const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
-            if (addGeoipDisableProperty) {
-                if (!message.properties) {
-                    message.properties = {};
-                }
-                message['properties']['$geoip_disable'] = true;
-            }
-            if (message.distinctId) {
-                message.distinct_id = message.distinctId;
-                delete message.distinctId;
-            }
+            const message = this.prepareMessage(type, _message, options);
             const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
             if (queue.length >= this.maxQueueSize) {
                 queue.shift();
@@ -1266,6 +1719,73 @@ class PostHogCoreStateless {
             }
         });
     }
+    async sendImmediate(type, _message, options) {
+        if (this.disabled) {
+            this.logMsgIfDebug(() => console.warn('[PostHog] The client is disabled'));
+            return;
+        }
+        if (!this._isInitialized) {
+            await this._initPromise;
+        }
+        if (this.optedOut) {
+            this._events.emit(type, `Library is disabled. Not sending event. To re-enable, call posthog.optIn()`);
+            return;
+        }
+        const data = {
+            api_key: this.apiKey,
+            batch: [this.prepareMessage(type, _message, options)],
+            sent_at: currentISOTime(),
+        };
+        if (this.historicalMigration) {
+            data.historical_migration = true;
+        }
+        const payload = JSON.stringify(data);
+        const url = this.captureMode === 'form'
+            ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
+            : `${this.host}/batch/`;
+        const fetchOptions = this.captureMode === 'form'
+            ? {
+                method: 'POST',
+                mode: 'no-cors',
+                credentials: 'omit',
+                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+            }
+            : {
+                method: 'POST',
+                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+                body: payload,
+            };
+        try {
+            await this.fetchWithRetry(url, fetchOptions);
+        }
+        catch (err) {
+            this._events.emit('error', err);
+            throw err;
+        }
+    }
+    prepareMessage(type, _message, options) {
+        const message = {
+            ..._message,
+            type: type,
+            library: this.getLibraryId(),
+            library_version: this.getLibraryVersion(),
+            timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
+            uuid: options?.uuid ? options.uuid : uuidv7(),
+        };
+        const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
+        if (addGeoipDisableProperty) {
+            if (!message.properties) {
+                message.properties = {};
+            }
+            message['properties']['$geoip_disable'] = true;
+        }
+        if (message.distinctId) {
+            message.distinct_id = message.distinctId;
+            delete message.distinctId;
+        }
+        return message;
+    }
     clearFlushTimer() {
         if (this._flushTimer) {
             clearTimeout(this._flushTimer);
@@ -1277,16 +1797,26 @@ class PostHogCoreStateless {
      * Avoids unnecessary promise errors
      */
     flushBackground() {
-        void this.flush().catch(() => { });
+        void this.flush().catch(async (err) => {
+            await logFlushError(err);
+        });
     }
     async flush() {
-        if (!this.flushPromise) {
-            this.flushPromise = this._flush().finally(() => {
+        // Wait for the current flush operation to finish (regardless of success or failure), then try to flush again.
+        // Use allSettled instead of finally to be defensive around flush throwing errors immediately rather than rejecting.
+        const nextFlushPromise = Promise.allSettled([this.flushPromise]).then(() => {
+            return this._flush();
+        });
+        this.flushPromise = nextFlushPromise;
+        void this.addPendingPromise(nextFlushPromise);
+        Promise.allSettled([nextFlushPromise]).then(() => {
+            // If there are no others waiting to flush, clear the promise.
+            // We don't strictly need to do this, but it could make debugging easier
+            if (this.flushPromise === nextFlushPromise) {
                 this.flushPromise = null;
-            });
-            this.addPendingPromise(this.flushPromise);
-        }
-        return this.flushPromise;
+            }
+        });
+        return nextFlushPromise;
     }
     getCustomHeaders() {
         // Don't set the user agent if we're not on a browser. The latest spec allows
@@ -1303,56 +1833,80 @@ class PostHogCoreStateless {
     async _flush() {
         this.clearFlushTimer();
         await this._initPromise;
-        const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+        let queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
         if (!queue.length) {
             return [];
         }
-        const items = queue.slice(0, this.maxBatchSize);
-        const messages = items.map((item) => item.message);
-        const persistQueueChange = () => {
-            const refreshedQueue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-            this.setPersistedProperty(PostHogPersistedProperty.Queue, refreshedQueue.slice(items.length));
-        };
-        const data = {
-            api_key: this.apiKey,
-            batch: messages,
-            sent_at: currentISOTime(),
-        };
-        if (this.historicalMigration) {
-            data.historical_migration = true;
-        }
-        const payload = JSON.stringify(data);
-        const url = this.captureMode === 'form'
-            ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
-            : `${this.host}/batch/`;
-        const fetchOptions = this.captureMode === 'form'
-            ? {
-                method: 'POST',
-                mode: 'no-cors',
-                credentials: 'omit',
-                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
-                body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+        const sentMessages = [];
+        const originalQueueLength = queue.length;
+        while (queue.length > 0 && sentMessages.length < originalQueueLength) {
+            const batchItems = queue.slice(0, this.maxBatchSize);
+            const batchMessages = batchItems.map((item) => item.message);
+            const persistQueueChange = () => {
+                const refreshedQueue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+                const newQueue = refreshedQueue.slice(batchItems.length);
+                this.setPersistedProperty(PostHogPersistedProperty.Queue, newQueue);
+                queue = newQueue;
+            };
+            const data = {
+                api_key: this.apiKey,
+                batch: batchMessages,
+                sent_at: currentISOTime(),
+            };
+            if (this.historicalMigration) {
+                data.historical_migration = true;
             }
-            : {
-                method: 'POST',
-                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
-                body: payload,
+            const payload = JSON.stringify(data);
+            const url = this.captureMode === 'form'
+                ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
+                : `${this.host}/batch/`;
+            const fetchOptions = this.captureMode === 'form'
+                ? {
+                    method: 'POST',
+                    mode: 'no-cors',
+                    credentials: 'omit',
+                    headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+                }
+                : {
+                    method: 'POST',
+                    headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+                    body: payload,
+                };
+            const retryOptions = {
+                retryCheck: (err) => {
+                    // don't automatically retry on 413 errors, we want to reduce the batch size first
+                    if (isPostHogFetchContentTooLargeError(err)) {
+                        return false;
+                    }
+                    // otherwise, retry on network errors
+                    return isPostHogFetchError(err);
+                },
             };
-        try {
-            await this.fetchWithRetry(url, fetchOptions);
-        }
-        catch (err) {
-            // depending on the error type, eg a malformed JSON or broken queue, it'll always return an error
-            // and this will be an endless loop, in this case, if the error isn't a network issue, we always remove the items from the queue
-            if (!(err instanceof PostHogFetchNetworkError)) {
-                persistQueueChange();
+            try {
+                await this.fetchWithRetry(url, fetchOptions, retryOptions);
             }
-            this._events.emit('error', err);
-            throw err;
+            catch (err) {
+                if (isPostHogFetchContentTooLargeError(err) && batchMessages.length > 1) {
+                    // if we get a 413 error, we want to reduce the batch size and try again
+                    this.maxBatchSize = Math.max(1, Math.floor(batchMessages.length / 2));
+                    this.logMsgIfDebug(() => console.warn(`Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`));
+                    // do not persist the queue change, we want to retry the same batch
+                    continue;
+                }
+                // depending on the error type, eg a malformed JSON or broken queue, it'll always return an error
+                // and this will be an endless loop, in this case, if the error isn't a network issue, we always remove the items from the queue
+                if (!(err instanceof PostHogFetchNetworkError)) {
+                    persistQueueChange();
+                }
+                this._events.emit('error', err);
+                throw err;
+            }
+            persistQueueChange();
+            sentMessages.push(...batchMessages);
         }
-        persistQueueChange();
-        this._events.emit('flush', messages);
-        return messages;
+        this._events.emit('flush', sentMessages);
+        return sentMessages;
     }
     async fetchWithRetry(url, options, retryOptions, requestTimeout) {
         var _a;
@@ -1361,6 +1915,8 @@ class PostHogCoreStateless {
             setTimeout(() => ctrl.abort(), ms);
             return ctrl.signal;
         });
+        const body = options.body ? options.body : '';
+        const reqByteLength = Buffer.byteLength(body, STRING_FORMAT);
         return await retriable(async () => {
             let res = null;
             try {
@@ -1378,12 +1934,12 @@ class PostHogCoreStateless {
             // https://developer.mozilla.org/en-US/docs/Web/API/Request/mode#no-cors
             const isNoCors = options.mode === 'no-cors';
             if (!isNoCors && (res.status < 200 || res.status >= 400)) {
-                throw new PostHogFetchHttpError(res);
+                throw new PostHogFetchHttpError(res, reqByteLength);
             }
             return res;
         }, { ...this._retryOptions, ...retryOptions });
     }
-    async shutdown(shutdownTimeoutMs = 30000) {
+    async _shutdown(shutdownTimeoutMs = 30000) {
         // A little tricky - we want to have a max shutdown time and enforce it, even if that means we have some
         // dangling promises. We'll keep track of the timeout and resolve/reject based on that.
         await this._initPromise;
@@ -1410,7 +1966,7 @@ class PostHogCoreStateless {
                 if (!isPostHogFetchError(e)) {
                     throw e;
                 }
-                this.logMsgIfDebug(() => console.error('Error while shutting down PostHog', e));
+                await logFlushError(e);
             }
         };
         return Promise.race([
@@ -1424,6 +1980,22 @@ class PostHogCoreStateless {
             doShutdown(),
         ]);
     }
+    /**
+     *  Call shutdown() once before the node process exits, so ensure that all events have been sent and all promises
+     *  have resolved. Do not use this function if you intend to keep using this PostHog instance after calling it.
+     * @param shutdownTimeoutMs
+     */
+    async shutdown(shutdownTimeoutMs = 30000) {
+        if (this.shutdownPromise) {
+            this.logMsgIfDebug(() => console.warn('shutdown() called while already shutting down. shutdown() is meant to be called once before process exit - use flush() for per-request cleanup'));
+        }
+        else {
+            this.shutdownPromise = this._shutdown(shutdownTimeoutMs).finally(() => {
+                this.shutdownPromise = null;
+            });
+        }
+        return this.shutdownPromise;
+    }
 }
 class PostHogCore extends PostHogCoreStateless {
     constructor(apiKey, options) {
@@ -1458,36 +2030,24 @@ class PostHogCore extends PostHogCoreStateless {
                 }
             }
         }
-        const bootstrapfeatureFlags = bootstrap.featureFlags;
-        if (bootstrapfeatureFlags && Object.keys(bootstrapfeatureFlags).length) {
-            const bootstrapFlags = Object.keys(bootstrapfeatureFlags)
-                .filter((flag) => !!bootstrapfeatureFlags[flag])
-                .reduce((res, key) => ((res[key] = bootstrapfeatureFlags[key] || false), res), {});
-            if (Object.keys(bootstrapFlags).length) {
-                this.setPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlags, bootstrapFlags);
-                const currentFlags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags) || {};
-                const newFeatureFlags = { ...bootstrapFlags, ...currentFlags };
-                this.setKnownFeatureFlags(newFeatureFlags);
-            }
-            const bootstrapFlagPayloads = bootstrap.featureFlagPayloads;
-            if (bootstrapFlagPayloads && Object.keys(bootstrapFlagPayloads).length) {
-                this.setPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagPayloads, bootstrapFlagPayloads);
-                const currentFlagPayloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads) || {};
-                const newFeatureFlagPayloads = { ...bootstrapFlagPayloads, ...currentFlagPayloads };
-                this.setKnownFeatureFlagPayloads(newFeatureFlagPayloads);
+        const bootstrapFeatureFlags = bootstrap.featureFlags;
+        const bootstrapFeatureFlagPayloads = bootstrap.featureFlagPayloads ?? {};
+        if (bootstrapFeatureFlags && Object.keys(bootstrapFeatureFlags).length) {
+            const normalizedBootstrapFeatureFlagDetails = createDecideResponseFromFlagsAndPayloads(bootstrapFeatureFlags, bootstrapFeatureFlagPayloads);
+            if (Object.keys(normalizedBootstrapFeatureFlagDetails.flags).length > 0) {
+                this.setBootstrappedFeatureFlagDetails(normalizedBootstrapFeatureFlagDetails);
+                const currentFeatureFlagDetails = this.getKnownFeatureFlagDetails() || { flags: {}, requestId: undefined };
+                const newFeatureFlagDetails = {
+                    flags: {
+                        ...normalizedBootstrapFeatureFlagDetails.flags,
+                        ...currentFeatureFlagDetails.flags,
+                    },
+                    requestId: normalizedBootstrapFeatureFlagDetails.requestId,
+                };
+                this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
             }
         }
     }
-    // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
-    get props() {
-        if (!this._props) {
-            this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
-        }
-        return this._props || {};
-    }
-    set props(val) {
-        this._props = val;
-    }
     clearProps() {
         this.props = undefined;
         this.sessionProps = {};
@@ -1577,21 +2137,6 @@ class PostHogCore extends PostHogCoreStateless {
         }
         return this.getPersistedProperty(PostHogPersistedProperty.DistinctId) || this.getAnonymousId();
     }
-    async unregister(property) {
-        this.wrap(() => {
-            delete this.props[property];
-            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
-        });
-    }
-    async register(properties) {
-        this.wrap(() => {
-            this.props = {
-                ...this.props,
-                ...properties,
-            };
-            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
-        });
-    }
     registerForSession(properties) {
         this.sessionProps = {
             ...this.sessionProps,
@@ -1712,7 +2257,7 @@ class PostHogCore extends PostHogCoreStateless {
     }
     resetPersonPropertiesForFlags() {
         this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, {});
+            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, null);
         });
     }
     /** @deprecated - Renamed to setPersonPropertiesForFlags */
@@ -1741,7 +2286,7 @@ class PostHogCore extends PostHogCoreStateless {
     }
     resetGroupPropertiesForFlags() {
         this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, {});
+            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, null);
         });
     }
     /** @deprecated - Renamed to setGroupPropertiesForFlags */
@@ -1750,6 +2295,13 @@ class PostHogCore extends PostHogCoreStateless {
             this.setGroupPropertiesForFlags(properties);
         });
     }
+    async remoteConfigAsync() {
+        await this._initPromise;
+        if (this._remoteConfigResponsePromise) {
+            return this._remoteConfigResponsePromise;
+        }
+        return this._remoteConfigAsync();
+    }
     /***
      *** FEATURE FLAGS
      ***/
@@ -1760,6 +2312,65 @@ class PostHogCore extends PostHogCoreStateless {
         }
         return this._decideAsync(sendAnonDistinctId);
     }
+    cacheSessionReplay(response) {
+        const sessionReplay = response?.sessionRecording;
+        if (sessionReplay) {
+            this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, sessionReplay);
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Session replay config: ', JSON.stringify(sessionReplay)));
+        }
+        else {
+            this.logMsgIfDebug(() => console.info('PostHog Debug', 'Session replay config disabled.'));
+            this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, null);
+        }
+    }
+    async _remoteConfigAsync() {
+        this._remoteConfigResponsePromise = this._initPromise
+            .then(() => {
+            let remoteConfig = this.getPersistedProperty(PostHogPersistedProperty.RemoteConfig);
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Cached remote config: ', JSON.stringify(remoteConfig)));
+            return super.getRemoteConfig().then((response) => {
+                if (response) {
+                    const remoteConfigWithoutSurveys = { ...response };
+                    delete remoteConfigWithoutSurveys.surveys;
+                    this.logMsgIfDebug(() => console.log('PostHog Debug', 'Fetched remote config: ', JSON.stringify(remoteConfigWithoutSurveys)));
+                    const surveys = response.surveys;
+                    let hasSurveys = true;
+                    if (!Array.isArray(surveys)) {
+                        // If surveys is not an array, it means there are no surveys (its a boolean instead)
+                        this.logMsgIfDebug(() => console.log('PostHog Debug', 'There are no surveys.'));
+                        hasSurveys = false;
+                    }
+                    else {
+                        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Surveys fetched from remote config: ', JSON.stringify(surveys)));
+                    }
+                    if (this.disableSurveys === false && hasSurveys) {
+                        this.setPersistedProperty(PostHogPersistedProperty.Surveys, surveys);
+                    }
+                    else {
+                        this.setPersistedProperty(PostHogPersistedProperty.Surveys, null);
+                    }
+                    // we cache the surveys in its own storage key
+                    this.setPersistedProperty(PostHogPersistedProperty.RemoteConfig, remoteConfigWithoutSurveys);
+                    this.cacheSessionReplay(response);
+                    // we only dont load flags if the remote config has no feature flags
+                    if (response.hasFeatureFlags === false) {
+                        // resetting flags to empty object
+                        this.setKnownFeatureFlagDetails({ flags: {} });
+                        this.logMsgIfDebug(() => console.warn('Remote config has no feature flags, will not load feature flags.'));
+                    }
+                    else if (this.preloadFeatureFlags !== false) {
+                        this.reloadFeatureFlags();
+                    }
+                    remoteConfig = response;
+                }
+                return remoteConfig;
+            });
+        })
+            .finally(() => {
+            this._remoteConfigResponsePromise = undefined;
+        });
+        return this._remoteConfigResponsePromise;
+    }
     async _decideAsync(sendAnonDistinctId = true) {
         this._decideResponsePromise = this._initPromise
             .then(async () => {
@@ -1775,8 +2386,7 @@ class PostHogCore extends PostHogCoreStateless {
             // Add check for quota limitation on feature flags
             if (res?.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
                 // Unset all feature flags by setting to null
-                this.setKnownFeatureFlags(null);
-                this.setKnownFeatureFlagPayloads(null);
+                this.setKnownFeatureFlagDetails(null);
                 console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - unsetting all flags. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
                 return res;
             }
@@ -1785,29 +2395,20 @@ class PostHogCore extends PostHogCoreStateless {
                 if (this.sendFeatureFlagEvent) {
                     this.flagCallReported = {};
                 }
-                let newFeatureFlags = res.featureFlags;
-                let newFeatureFlagPayloads = res.featureFlagPayloads;
+                let newFeatureFlagDetails = res;
                 if (res.errorsWhileComputingFlags) {
                     // if not all flags were computed, we upsert flags instead of replacing them
-                    const currentFlags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
-                    this.logMsgIfDebug(() => console.log('PostHog Debug', 'Cached feature flags: ', JSON.stringify(currentFlags)));
-                    const currentFlagPayloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
-                    newFeatureFlags = { ...currentFlags, ...res.featureFlags };
-                    newFeatureFlagPayloads = { ...currentFlagPayloads, ...res.featureFlagPayloads };
+                    const currentFlagDetails = this.getKnownFeatureFlagDetails();
+                    this.logMsgIfDebug(() => console.log('PostHog Debug', 'Cached feature flags: ', JSON.stringify(currentFlagDetails)));
+                    newFeatureFlagDetails = {
+                        ...res,
+                        flags: { ...currentFlagDetails?.flags, ...res.flags },
+                    };
                 }
-                this.setKnownFeatureFlags(newFeatureFlags);
-                this.setKnownFeatureFlagPayloads(Object.fromEntries(Object.entries(newFeatureFlagPayloads || {}).map(([k, v]) => [k, this._parsePayload(v)])));
+                this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
                 // Mark that we hit the /decide endpoint so we can capture this in the $feature_flag_called event
                 this.setPersistedProperty(PostHogPersistedProperty.DecideEndpointWasHit, true);
-                const sessionReplay = res?.sessionRecording;
-                if (sessionReplay) {
-                    this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, sessionReplay);
-                    this.logMsgIfDebug(() => console.log('PostHog Debug', 'Session replay config: ', JSON.stringify(sessionReplay)));
-                }
-                else {
-                    this.logMsgIfDebug(() => console.info('PostHog Debug', 'Session replay config disabled.'));
-                    this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, null);
-                }
+                this.cacheSessionReplay(res);
             }
             return res;
         })
@@ -1816,38 +2417,91 @@ class PostHogCore extends PostHogCoreStateless {
         });
         return this._decideResponsePromise;
     }
-    setKnownFeatureFlags(featureFlags) {
+    // We only store the flags and request id in the feature flag details storage key
+    setKnownFeatureFlagDetails(decideResponse) {
         this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlags, featureFlags);
-            this._events.emit('featureflags', featureFlags);
+            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails, decideResponse);
+            this._events.emit('featureflags', getFlagValuesFromFlags(decideResponse?.flags ?? {}));
         });
     }
-    setKnownFeatureFlagPayloads(featureFlagPayloads) {
-        this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads, featureFlagPayloads);
-        });
+    getKnownFeatureFlagDetails() {
+        const storedDetails = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails);
+        if (!storedDetails) {
+            // Rebuild from the stored feature flags and feature flag payloads
+            const featureFlags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+            const featureFlagPayloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
+            if (featureFlags === undefined && featureFlagPayloads === undefined) {
+                return undefined;
+            }
+            return createDecideResponseFromFlagsAndPayloads(featureFlags ?? {}, featureFlagPayloads ?? {});
+        }
+        return normalizeDecideResponse(storedDetails);
+    }
+    getKnownFeatureFlags() {
+        const featureFlagDetails = this.getKnownFeatureFlagDetails();
+        if (!featureFlagDetails) {
+            return undefined;
+        }
+        return getFlagValuesFromFlags(featureFlagDetails.flags);
+    }
+    getKnownFeatureFlagPayloads() {
+        const featureFlagDetails = this.getKnownFeatureFlagDetails();
+        if (!featureFlagDetails) {
+            return undefined;
+        }
+        return getPayloadsFromFlags(featureFlagDetails.flags);
+    }
+    getBootstrappedFeatureFlagDetails() {
+        const details = this.getPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagDetails);
+        if (!details) {
+            return undefined;
+        }
+        return details;
+    }
+    setBootstrappedFeatureFlagDetails(details) {
+        this.setPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagDetails, details);
+    }
+    getBootstrappedFeatureFlags() {
+        const details = this.getBootstrappedFeatureFlagDetails();
+        if (!details) {
+            return undefined;
+        }
+        return getFlagValuesFromFlags(details.flags);
+    }
+    getBootstrappedFeatureFlagPayloads() {
+        const details = this.getBootstrappedFeatureFlagDetails();
+        if (!details) {
+            return undefined;
+        }
+        return getPayloadsFromFlags(details.flags);
     }
     getFeatureFlag(key) {
-        const featureFlags = this.getFeatureFlags();
-        if (!featureFlags) {
+        const details = this.getFeatureFlagDetails();
+        if (!details) {
             // If we haven't loaded flags yet, or errored out, we respond with undefined
             return undefined;
         }
-        let response = featureFlags[key];
-        // `/decide` v3 returns all flags
+        const featureFlag = details.flags[key];
+        let response = getFeatureFlagValue(featureFlag);
         if (response === undefined) {
             // For cases where the flag is unknown, return false
             response = false;
         }
         if (this.sendFeatureFlagEvent && !this.flagCallReported[key]) {
+            const bootstrappedResponse = this.getBootstrappedFeatureFlags()?.[key];
+            const bootstrappedPayload = this.getBootstrappedFeatureFlagPayloads()?.[key];
             this.flagCallReported[key] = true;
             this.capture('$feature_flag_called', {
                 $feature_flag: key,
                 $feature_flag_response: response,
-                $feature_flag_bootstrapped_response: this.getPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlags)?.[key],
-                $feature_flag_bootstrapped_payload: this.getPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagPayloads)?.[key],
+                $feature_flag_id: featureFlag?.metadata?.id,
+                $feature_flag_version: featureFlag?.metadata?.version,
+                $feature_flag_reason: featureFlag?.reason?.description ?? featureFlag?.reason?.code,
+                $feature_flag_bootstrapped_response: bootstrappedResponse,
+                $feature_flag_bootstrapped_payload: bootstrappedPayload,
                 // If we haven't yet received a response from the /decide endpoint, we must have used the bootstrapped value
                 $used_bootstrap_value: !this.getPersistedProperty(PostHogPersistedProperty.DecideEndpointWasHit),
+                $feature_flag_request_id: details.requestId,
             });
         }
         // If we have flags we either return the value (true or string) or false
@@ -1866,27 +2520,36 @@ class PostHogCore extends PostHogCoreStateless {
         return response;
     }
     getFeatureFlagPayloads() {
-        const payloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
-        return payloads;
+        return this.getFeatureFlagDetails()?.featureFlagPayloads;
     }
     getFeatureFlags() {
         // NOTE: We don't check for _initPromise here as the function is designed to be
         // callable before the state being loaded anyways
-        let flags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+        return this.getFeatureFlagDetails()?.featureFlags;
+    }
+    getFeatureFlagDetails() {
+        // NOTE: We don't check for _initPromise here as the function is designed to be
+        // callable before the state being loaded anyways
+        let details = this.getKnownFeatureFlagDetails();
         const overriddenFlags = this.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags);
         if (!overriddenFlags) {
-            return flags;
+            return details;
         }
-        flags = flags || {};
+        details = details ?? { featureFlags: {}, featureFlagPayloads: {}, flags: {} };
+        const flags = details.flags ?? {};
         for (const key in overriddenFlags) {
             if (!overriddenFlags[key]) {
                 delete flags[key];
             }
             else {
-                flags[key] = overriddenFlags[key];
+                flags[key] = updateFlagValue(flags[key], overriddenFlags[key]);
             }
         }
-        return flags;
+        const result = {
+            ...details,
+            flags,
+        };
+        return normalizeDecideResponse(result);
     }
     getFeatureFlagsAndPayloads() {
         const flags = this.getFeatureFlags();
@@ -1916,6 +2579,9 @@ class PostHogCore extends PostHogCoreStateless {
             }
         });
     }
+    async reloadRemoteConfigAsync() {
+        return await this.remoteConfigAsync();
+    }
     async reloadFeatureFlagsAsync(sendAnonDistinctId = true) {
         return (await this.decideAsync(sendAnonDistinctId))?.featureFlags;
     }
@@ -1990,8 +2656,6 @@ class PostHogCore extends PostHogCoreStateless {
     }
 }
 
-var version = "3.4.2";
-
 function getContext(window) {
   let context = {};
   if (window?.navigator) {
@@ -2295,9 +2959,51 @@ const getStorage = (type, window) => {
   }
 };
 
+// import { patch } from 'rrweb/typings/utils'
+// copied from: https://github.com/PostHog/posthog-js/blob/main/src/extensions/replay/rrweb-plugins/patch.ts
+// which was copied from https://github.com/rrweb-io/rrweb/blob/8aea5b00a4dfe5a6f59bd2ae72bb624f45e51e81/packages/rrweb/src/utils.ts#L129
+// which was copied from https://github.com/getsentry/sentry-javascript/blob/b2109071975af8bf0316d3b5b38f519bdaf5dc15/packages/utils/src/object.ts
+// copied from: https://github.com/PostHog/posthog-js/blob/main/react/src/utils/type-utils.ts#L4
+const isFunction = function (f) {
+  return typeof f === 'function';
+};
+function patch(source, name, replacement) {
+  try {
+    if (!(name in source)) {
+      return () => {
+        //
+      };
+    }
+    const original = source[name];
+    const wrapped = replacement(original);
+    // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work
+    // otherwise it'll throw "TypeError: Object.defineProperties called on non-object"
+    if (isFunction(wrapped)) {
+      wrapped.prototype = wrapped.prototype || {};
+      Object.defineProperties(wrapped, {
+        __posthog_wrapped__: {
+          enumerable: false,
+          value: true
+        }
+      });
+    }
+    source[name] = wrapped;
+    return () => {
+      source[name] = original;
+    };
+  } catch {
+    return () => {
+      //
+    };
+    // This can throw if multiple fill happens on a global object like XMLHttpRequest
+    // Fixes https://github.com/getsentry/sentry-javascript/issues/2043
+  }
+}
+
 class PostHog extends PostHogCore {
   constructor(apiKey, options) {
     super(apiKey, options);
+    this._lastPathname = '';
     // posthog-js stores options in one object on
     this._storageKey = options?.persistence_name ? `ph_${options.persistence_name}` : `ph_${apiKey}_posthog`;
     this._storage = getStorage(options?.persistence || 'localStorage', this.getWindow());
@@ -2305,6 +3011,10 @@ class PostHog extends PostHogCore {
     if (options?.preloadFeatureFlags !== false) {
       this.reloadFeatureFlags();
     }
+    if (options?.captureHistoryEvents && typeof window !== 'undefined') {
+      this._lastPathname = window?.location?.pathname || '';
+      this.setupHistoryEventTracking();
+    }
   }
   getWindow() {
     return typeof window !== 'undefined' ? window : undefined;
@@ -2349,8 +3059,49 @@ class PostHog extends PostHogCore {
       ...getContext(this.getWindow())
     };
   }
+  setupHistoryEventTracking() {
+    const window = this.getWindow();
+    if (!window) {
+      return;
+    }
+    // Old fashioned, we could also use arrow functions but I think the closure for a patch is more reliable
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    patch(window.history, 'pushState', originalPushState => {
+      return function patchedPushState(state, title, url) {
+        ;
+        originalPushState.call(this, state, title, url);
+        self.captureNavigationEvent('pushState');
+      };
+    });
+    patch(window.history, 'replaceState', originalReplaceState => {
+      return function patchedReplaceState(state, title, url) {
+        ;
+        originalReplaceState.call(this, state, title, url);
+        self.captureNavigationEvent('replaceState');
+      };
+    });
+    // For popstate we need to listen to the event instead of overriding a method
+    window.addEventListener('popstate', () => {
+      this.captureNavigationEvent('popstate');
+    });
+  }
+  captureNavigationEvent(navigationType) {
+    const window = this.getWindow();
+    if (!window) {
+      return;
+    }
+    const currentPathname = window.location.pathname;
+    // Only capture pageview if the pathname has changed
+    if (currentPathname !== this._lastPathname) {
+      this.capture('$pageview', {
+        navigation_type: navigationType
+      });
+      this._lastPathname = currentPathname;
+    }
+  }
 }
 
 exports.PostHog = PostHog;
 exports["default"] = PostHog;
-//# sourceMappingURL=index.cjs.js.map
+//# sourceMappingURL=index.cjs.map