posthog-js-lite 4.0.0 → 4.1.0

package/lib/index.d.ts

@@ -77,11 +77,11 @@ declare enum PostHogPersistedProperty {
     InstalledAppBuild = "installed_app_build",
     InstalledAppVersion = "installed_app_version",
     SessionReplay = "session_replay",
-    DecideEndpointWasHit = "decide_endpoint_was_hit",
     SurveyLastSeenDate = "survey_last_seen_date",
     SurveysSeen = "surveys_seen",
     Surveys = "surveys",
-    RemoteConfig = "remote_config"
+    RemoteConfig = "remote_config",
+    FlagsEndpointWasHit = "flags_endpoint_was_hit"
 }
 type PostHogFetchOptions = {
     method: 'GET' | 'POST' | 'PUT' | 'PATCH';
@@ -141,7 +141,7 @@ type PostHogRemoteConfig = {
     hasFeatureFlags?: boolean;
 };
 type FeatureFlagValue = string | boolean;
-type PostHogDecideResponse = Omit<PostHogRemoteConfig, 'surveys' | 'hasFeatureFlags'> & {
+type PostHogFlagsResponse = Omit<PostHogRemoteConfig, 'surveys' | 'hasFeatureFlags'> & {
     featureFlags: {
         [key: string]: FeatureFlagValue;
     };
@@ -187,9 +187,9 @@ type PartialWithRequired<T, K extends keyof T> = {
     [P in Exclude<keyof T, K>]?: T[P];
 };
 /**
- * These are the fields we care about from PostHogDecideResponse for feature flags.
+ * These are the fields we care about from PostHogFlagsResponse for feature flags.
  */
-type PostHogFeatureFlagDetails = PartialWithRequired<PostHogDecideResponse, 'flags' | 'featureFlags' | 'featureFlagPayloads' | 'requestId'>;
+type PostHogFeatureFlagDetails = PartialWithRequired<PostHogFlagsResponse, 'flags' | 'featureFlags' | 'featureFlagPayloads' | 'requestId'>;
 type JsonType = string | number | boolean | null | {
     [key: string]: JsonType;
 } | Array<JsonType> | JsonType[];
@@ -465,7 +465,7 @@ declare abstract class PostHogCoreStateless {
     /***
      *** FEATURE FLAGS
      ***/
-    protected getDecide(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, extraPayload?: Record<string, any>): Promise<PostHogDecideResponse | undefined>;
+    protected getFlags(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, extraPayload?: Record<string, any>): Promise<PostHogFlagsResponse | undefined>;
     protected getFeatureFlagStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<{
         response: FeatureFlagValue | undefined;
         requestId: string | undefined;
@@ -475,16 +475,16 @@ declare abstract class PostHogCoreStateless {
         requestId: string | undefined;
     } | undefined>;
     protected getFeatureFlagPayloadStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<JsonType | undefined>;
-    protected getFeatureFlagPayloadsStateless(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogDecideResponse['featureFlagPayloads'] | undefined>;
+    protected getFeatureFlagPayloadsStateless(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogFlagsResponse['featureFlagPayloads'] | undefined>;
     protected getFeatureFlagsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<{
-        flags: PostHogDecideResponse['featureFlags'] | undefined;
-        payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
-        requestId: PostHogDecideResponse['requestId'] | undefined;
+        flags: PostHogFlagsResponse['featureFlags'] | undefined;
+        payloads: PostHogFlagsResponse['featureFlagPayloads'] | undefined;
+        requestId: PostHogFlagsResponse['requestId'] | undefined;
     }>;
     protected getFeatureFlagsAndPayloadsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<{
-        flags: PostHogDecideResponse['featureFlags'] | undefined;
-        payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
-        requestId: PostHogDecideResponse['requestId'] | undefined;
+        flags: PostHogFlagsResponse['featureFlags'] | undefined;
+        payloads: PostHogFlagsResponse['featureFlagPayloads'] | undefined;
+        requestId: PostHogFlagsResponse['requestId'] | undefined;
     }>;
     protected getFeatureFlagDetailsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogFeatureFlagDetails | undefined>;
     /***
@@ -550,7 +550,7 @@ declare abstract class PostHogCoreStateless {
 declare abstract class PostHogCore extends PostHogCoreStateless {
     private sendFeatureFlagEvent;
     private flagCallReported;
-    protected _decideResponsePromise?: Promise<PostHogDecideResponse | undefined>;
+    protected _flagsResponsePromise?: Promise<PostHogFlagsResponse | undefined>;
     protected _sessionExpirationTimeSeconds: number;
     private _sessionMaxLengthSeconds;
     protected sessionProps: PostHogEventProperties;
@@ -604,13 +604,13 @@ declare abstract class PostHogCore extends PostHogCoreStateless {
     /***
      *** FEATURE FLAGS
      ***/
-    private decideAsync;
+    private flagsAsync;
     private cacheSessionReplay;
     private _remoteConfigAsync;
-    private _decideAsync;
+    private _flagsAsync;
     private setKnownFeatureFlagDetails;
     private getKnownFeatureFlagDetails;
-    protected getKnownFeatureFlags(): PostHogDecideResponse['featureFlags'] | undefined;
+    protected getKnownFeatureFlags(): PostHogFlagsResponse['featureFlags'] | undefined;
     private getKnownFeatureFlagPayloads;
     private getBootstrappedFeatureFlagDetails;
     private setBootstrappedFeatureFlagDetails;
@@ -618,20 +618,22 @@ declare abstract class PostHogCore extends PostHogCoreStateless {
     private getBootstrappedFeatureFlagPayloads;
     getFeatureFlag(key: string): FeatureFlagValue | undefined;
     getFeatureFlagPayload(key: string): JsonType | undefined;
-    getFeatureFlagPayloads(): PostHogDecideResponse['featureFlagPayloads'] | undefined;
-    getFeatureFlags(): PostHogDecideResponse['featureFlags'] | undefined;
+    getFeatureFlagPayloads(): PostHogFlagsResponse['featureFlagPayloads'] | undefined;
+    getFeatureFlags(): PostHogFlagsResponse['featureFlags'] | undefined;
     getFeatureFlagDetails(): PostHogFeatureFlagDetails | undefined;
     getFeatureFlagsAndPayloads(): {
-        flags: PostHogDecideResponse['featureFlags'] | undefined;
-        payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
+        flags: PostHogFlagsResponse['featureFlags'] | undefined;
+        payloads: PostHogFlagsResponse['featureFlagPayloads'] | undefined;
     };
     isFeatureEnabled(key: string): boolean | undefined;
-    reloadFeatureFlags(cb?: (err?: Error, flags?: PostHogDecideResponse['featureFlags']) => void): void;
+    reloadFeatureFlags(options?: {
+        cb?: (err?: Error, flags?: PostHogFlagsResponse['featureFlags']) => void;
+    }): void;
     reloadRemoteConfigAsync(): Promise<PostHogRemoteConfig | undefined>;
-    reloadFeatureFlagsAsync(sendAnonDistinctId?: boolean): Promise<PostHogDecideResponse['featureFlags'] | undefined>;
-    onFeatureFlags(cb: (flags: PostHogDecideResponse['featureFlags']) => void): () => void;
+    reloadFeatureFlagsAsync(sendAnonDistinctId?: boolean): Promise<PostHogFlagsResponse['featureFlags'] | undefined>;
+    onFeatureFlags(cb: (flags: PostHogFlagsResponse['featureFlags']) => void): () => void;
     onFeatureFlag(key: string, cb: (value: FeatureFlagValue) => void): () => void;
-    overrideFeatureFlag(flags: PostHogDecideResponse['featureFlags'] | null): Promise<void>;
+    overrideFeatureFlag(flags: PostHogFlagsResponse['featureFlags'] | null): Promise<void>;
     /***
      *** ERROR TRACKING
      ***/

package/lib/index.mjs

@@ -1,4 +1,4 @@
-var version = "4.0.0";
+var version = "4.1.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -22,11 +22,11 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
     PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
     PostHogPersistedProperty["SessionReplay"] = "session_replay";
-    PostHogPersistedProperty["DecideEndpointWasHit"] = "decide_endpoint_was_hit";
     PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
     PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
     PostHogPersistedProperty["Surveys"] = "surveys";
     PostHogPersistedProperty["RemoteConfig"] = "remote_config";
+    PostHogPersistedProperty["FlagsEndpointWasHit"] = "flags_endpoint_was_hit";
 })(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
 // Any key prefixed with `attr__` can be added
 var Compression;
@@ -94,27 +94,27 @@ var ActionStepStringMatching;
     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);
+const normalizeFlagsResponse = (flagsResponse) => {
+    if ('flags' in flagsResponse) {
+        // Convert v2 format to v1 format
+        const featureFlags = getFlagValuesFromFlags(flagsResponse.flags);
+        const featureFlagPayloads = getPayloadsFromFlags(flagsResponse.flags);
         return {
-            ...decideResponse,
+            ...flagsResponse,
             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)]));
+        // Convert v1 format to v2 format
+        const featureFlags = flagsResponse.featureFlags ?? {};
+        const featureFlagPayloads = Object.fromEntries(Object.entries(flagsResponse.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,
+            ...flagsResponse,
             featureFlags,
             featureFlagPayloads,
             flags,
@@ -186,7 +186,7 @@ const parsePayload = (response) => {
  * @param featureFlagPayloads - The feature flag payloads
  * @returns The normalized flag details
  */
-const createDecideResponseFromFlagsAndPayloads = (featureFlags, featureFlagPayloads) => {
+const createFlagsResponseFromFlagsAndPayloads = (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
@@ -196,7 +196,7 @@ const createDecideResponseFromFlagsAndPayloads = (featureFlags, featureFlagPaylo
         featureFlags: enabledFlags,
         featureFlagPayloads: featureFlagPayloads ?? {},
     };
-    return normalizeDecideResponse(flagDetails);
+    return normalizeFlagsResponse(flagDetails);
 };
 const updateFlagValue = (flag, value) => {
     return {
@@ -212,90 +212,6 @@ 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 || typeof truthyValue !== 'string' || isEmpty(truthyValue)) {
@@ -351,30 +267,6 @@ const isError = (x) => {
 function getFetch() {
     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;
-}
 function allSettled(promises) {
     return Promise.all(promises.map((p) => (p ?? Promise.resolve()).then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason }))));
 }
@@ -1106,13 +998,9 @@ class PostHogCoreStateless {
     /***
      *** FEATURE FLAGS
      ***/
-    async getDecide(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
+    async getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
         await this._initPromise;
-        // 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 url = `${this.host}/flags/?v=2&config=true`;
         const fetchOptions = {
             method: 'POST',
             headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
@@ -1125,11 +1013,11 @@ class PostHogCoreStateless {
                 ...extraPayload,
             }),
         };
-        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Decide URL', url));
-        // Don't retry /decide API calls
+        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Flags URL', url));
+        // Don't retry /flags API calls
         return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
             .then((response) => response.json())
-            .then((response) => normalizeDecideResponse(response))
+            .then((response) => normalizeFlagsResponse(response))
             .catch((error) => {
             this._events.emit('error', error);
             return undefined;
@@ -1158,15 +1046,15 @@ class PostHogCoreStateless {
     }
     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) {
+        const flagsResponse = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
+        if (flagsResponse === undefined) {
             return undefined;
         }
-        const featureFlags = decideResponse.flags;
+        const featureFlags = flagsResponse.flags;
         const flagDetail = featureFlags[key];
         return {
             response: flagDetail,
-            requestId: decideResponse.requestId,
+            requestId: flagsResponse.requestId,
         };
     }
     async getFeatureFlagPayloadStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
@@ -1216,26 +1104,26 @@ class PostHogCoreStateless {
         if (flagKeysToEvaluate) {
             extraPayload['flag_keys_to_evaluate'] = flagKeysToEvaluate;
         }
-        const decideResponse = await this.getDecide(distinctId, groups, personProperties, groupProperties, extraPayload);
-        if (decideResponse === undefined) {
+        const flagsResponse = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
+        if (flagsResponse === 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) {
+        // if there's an error on the flagsResponse, log a console error, but don't throw an error
+        if (flagsResponse.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 (flagsResponse.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: {},
                 featureFlags: {},
                 featureFlagPayloads: {},
-                requestId: decideResponse?.requestId,
+                requestId: flagsResponse?.requestId,
             };
         }
-        return decideResponse;
+        return flagsResponse;
     }
     /***
      *** SURVEYS
@@ -1667,7 +1555,7 @@ class PostHogCore extends PostHogCoreStateless {
         const bootstrapFeatureFlags = bootstrap.featureFlags;
         const bootstrapFeatureFlagPayloads = bootstrap.featureFlagPayloads ?? {};
         if (bootstrapFeatureFlags && Object.keys(bootstrapFeatureFlags).length) {
-            const normalizedBootstrapFeatureFlagDetails = createDecideResponseFromFlagsAndPayloads(bootstrapFeatureFlags, bootstrapFeatureFlagPayloads);
+            const normalizedBootstrapFeatureFlagDetails = createFlagsResponseFromFlagsAndPayloads(bootstrapFeatureFlags, bootstrapFeatureFlagPayloads);
             if (Object.keys(normalizedBootstrapFeatureFlagDetails.flags).length > 0) {
                 this.setBootstrappedFeatureFlagDetails(normalizedBootstrapFeatureFlagDetails);
                 const currentFeatureFlagDetails = this.getKnownFeatureFlagDetails() || { flags: {}, requestId: undefined };
@@ -1809,7 +1697,7 @@ class PostHogCore extends PostHogCoreStateless {
                 ...maybeAdd('$set_once', userPropsOnce),
             });
             if (distinctId !== previousDistinctId) {
-                // We keep the AnonymousId to be used by decide calls and identify to link the previousId
+                // We keep the AnonymousId to be used by flags calls and identify to link the previousId
                 this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, previousDistinctId);
                 this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
                 this.reloadFeatureFlags();
@@ -1937,12 +1825,12 @@ class PostHogCore extends PostHogCoreStateless {
     /***
      *** FEATURE FLAGS
      ***/
-    async decideAsync(sendAnonDistinctId = true) {
+    async flagsAsync(sendAnonDistinctId = true) {
         await this._initPromise;
-        if (this._decideResponsePromise) {
-            return this._decideResponsePromise;
+        if (this._flagsResponsePromise) {
+            return this._flagsResponsePromise;
         }
-        return this._decideAsync(sendAnonDistinctId);
+        return this._flagsAsync(sendAnonDistinctId);
     }
     cacheSessionReplay(source, response) {
         const sessionReplay = response?.sessionRecording;
@@ -2013,8 +1901,8 @@ class PostHogCore extends PostHogCoreStateless {
         });
         return this._remoteConfigResponsePromise;
     }
-    async _decideAsync(sendAnonDistinctId = true) {
-        this._decideResponsePromise = this._initPromise
+    async _flagsAsync(sendAnonDistinctId = true) {
+        this._flagsResponsePromise = this._initPromise
             .then(async () => {
             const distinctId = this.getDistinctId();
             const groups = this.props.$groups || {};
@@ -2024,7 +1912,7 @@ class PostHogCore extends PostHogCoreStateless {
             const extraProperties = {
                 $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
             };
-            const res = await super.getDecide(distinctId, groups, personProperties, groupProperties, extraProperties);
+            const res = await super.getFlags(distinctId, groups, personProperties, groupProperties, extraProperties);
             // Add check for quota limitation on feature flags
             if (res?.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
                 // Unset all feature flags by setting to null
@@ -2048,22 +1936,22 @@ class PostHogCore extends PostHogCoreStateless {
                     };
                 }
                 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);
-                this.cacheSessionReplay('decide/flags', res);
+                // Mark that we hit the /flags endpoint so we can capture this in the $feature_flag_called event
+                this.setPersistedProperty(PostHogPersistedProperty.FlagsEndpointWasHit, true);
+                this.cacheSessionReplay('flags', res);
             }
             return res;
         })
             .finally(() => {
-            this._decideResponsePromise = undefined;
+            this._flagsResponsePromise = undefined;
         });
-        return this._decideResponsePromise;
+        return this._flagsResponsePromise;
     }
     // We only store the flags and request id in the feature flag details storage key
-    setKnownFeatureFlagDetails(decideResponse) {
+    setKnownFeatureFlagDetails(flagsResponse) {
         this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails, decideResponse);
-            this._events.emit('featureflags', getFlagValuesFromFlags(decideResponse?.flags ?? {}));
+            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails, flagsResponse);
+            this._events.emit('featureflags', getFlagValuesFromFlags(flagsResponse?.flags ?? {}));
         });
     }
     getKnownFeatureFlagDetails() {
@@ -2075,9 +1963,9 @@ class PostHogCore extends PostHogCoreStateless {
             if (featureFlags === undefined && featureFlagPayloads === undefined) {
                 return undefined;
             }
-            return createDecideResponseFromFlagsAndPayloads(featureFlags ?? {}, featureFlagPayloads ?? {});
+            return createFlagsResponseFromFlagsAndPayloads(featureFlags ?? {}, featureFlagPayloads ?? {});
         }
-        return normalizeDecideResponse(storedDetails);
+        return normalizeFlagsResponse(storedDetails);
     }
     getKnownFeatureFlags() {
         const featureFlagDetails = this.getKnownFeatureFlagDetails();
@@ -2141,8 +2029,8 @@ class PostHogCore extends PostHogCoreStateless {
                 ...maybeAdd('$feature_flag_reason', featureFlag?.reason?.description ?? featureFlag?.reason?.code),
                 ...maybeAdd('$feature_flag_bootstrapped_response', bootstrappedResponse),
                 ...maybeAdd('$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),
+                // If we haven't yet received a response from the /flags endpoint, we must have used the bootstrapped value
+                $used_bootstrap_value: !this.getPersistedProperty(PostHogPersistedProperty.FlagsEndpointWasHit),
                 ...maybeAdd('$feature_flag_request_id', details.requestId),
             });
         }
@@ -2191,7 +2079,7 @@ class PostHogCore extends PostHogCoreStateless {
             ...details,
             flags,
         };
-        return normalizeDecideResponse(result);
+        return normalizeFlagsResponse(result);
     }
     getFeatureFlagsAndPayloads() {
         const flags = this.getFeatureFlags();
@@ -2209,14 +2097,14 @@ class PostHogCore extends PostHogCoreStateless {
         return !!response;
     }
     // Used when we want to trigger the reload but we don't care about the result
-    reloadFeatureFlags(cb) {
-        this.decideAsync()
+    reloadFeatureFlags(options) {
+        this.flagsAsync(true)
             .then((res) => {
-            cb?.(undefined, res?.featureFlags);
+            options?.cb?.(undefined, res?.featureFlags);
         })
             .catch((e) => {
-            cb?.(e, undefined);
-            if (!cb) {
+            options?.cb?.(e, undefined);
+            if (!options?.cb) {
                 this.logMsgIfDebug(() => console.log('PostHog Debug', 'Error reloading feature flags', e));
             }
         });
@@ -2224,8 +2112,8 @@ class PostHogCore extends PostHogCoreStateless {
     async reloadRemoteConfigAsync() {
         return await this.remoteConfigAsync();
     }
-    async reloadFeatureFlagsAsync(sendAnonDistinctId = true) {
-        return (await this.decideAsync(sendAnonDistinctId))?.featureFlags;
+    async reloadFeatureFlagsAsync(sendAnonDistinctId) {
+        return (await this.flagsAsync(sendAnonDistinctId ?? true))?.featureFlags;
     }
     onFeatureFlags(cb) {
         return this.on('featureflags', async () => {