Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

36.9 KB
Raw Blame
import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import { actionToUrl, router, urlToAction } from 'kea-router'

import { LemonTagType, PaginationManual } from '@posthog/lemon-ui'

import api, { CountedPaginatedResponse } from 'lib/api'
import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
import { parseNumericArrayFilter, parseTagsFilter, toParams } from 'lib/utils/url'
import { getFlagVariants } from 'scenes/experiments/utils'
import { FLAGS_PER_PAGE, type FeatureFlagsResult, featureFlagsLogic } from 'scenes/feature-flags/featureFlagsLogic'
import { projectLogic } from 'scenes/projectLogic'
import { teamLogic } from 'scenes/teamLogic'
import { urls } from 'scenes/urls'
import { userLogic } from 'scenes/userLogic'

import { SIDE_PANEL_CONTEXT_KEY, SidePanelSceneContext } from '~/layout/navigation-3000/sidepanel/types'
import {
    ActivityScope,
    Breadcrumb,
    Experiment,
    ExperimentStatus,
    ExperimentVelocityStats,
    ExperimentsTabs,
    FeatureFlagType,
} from '~/types'
import type { AvailableFeature, UserType } from '~/types'
import type { TeamPublicType, TeamType } from '~/types'

export const EXPERIMENTS_PER_PAGE = 100

export interface ExperimentsResult extends CountedPaginatedResponse<Experiment> {
    /* not in the API response */
    filters?: ExperimentsFilters | null
}

export interface ExperimentsFilters {
    search?: string
    status?: ExperimentStatus | 'all'
    created_by_id?: number[]
    archived?: boolean
    page?: number
    order?: string
    tags?: string[]
    excluded_tags?: string[]
}

export interface FeatureFlagModalFilters {
    active?: string
    created_by_id?: number[]
    search?: string
    order?: string
    page?: number
    evaluation_runtime?: string
}

const DEFAULT_FILTERS: ExperimentsFilters = {
    search: undefined,
    status: 'all',
    created_by_id: undefined,
    archived: false,
    page: 1,
    order: undefined,
    tags: undefined,
    excluded_tags: undefined,
}

const DEFAULT_MODAL_FILTERS: FeatureFlagModalFilters = {
    active: undefined,
    created_by_id: undefined,
    search: undefined,
    order: undefined,
    page: 1,
    evaluation_runtime: undefined,
}

export function isSingleVariantShipped(experiment: Experiment): boolean {
    const filters = experiment.feature_flag?.filters

    return (
        !!filters &&
        experiment.feature_flag?.active !== false &&
        Array.isArray(filters.groups?.[0]?.properties) &&
        filters.groups?.[0]?.properties?.length === 0 &&
        filters.groups?.[0]?.rollout_percentage === 100 &&
        getFlagVariants(experiment.feature_flag).some(({ rollout_percentage }) => rollout_percentage === 100)
    )
}

export function getShippedVariantKey(experiment: Experiment): string | null {
    if (!isSingleVariantShipped(experiment)) {
        return null
    }
    return (
        getFlagVariants(experiment.feature_flag).find(({ rollout_percentage }) => rollout_percentage === 100)?.key ||
        null
    )
}

export function getExperimentStatusLabel(status: ExperimentStatus): string {
    switch (status) {
        case ExperimentStatus.Draft:
            return 'Draft'
        case ExperimentStatus.Running:
            return 'Running'
        case ExperimentStatus.Paused:
            return 'Paused'
        case ExperimentStatus.ExposureFrozen:
            return 'Exposure frozen'
        case ExperimentStatus.Stopped:
            return 'Complete'
    }
}

export function getExperimentStatusColor(status: ExperimentStatus): LemonTagType {
    switch (status) {
        case ExperimentStatus.Draft:
            return 'default'
        case ExperimentStatus.Running:
            return 'success'
        case ExperimentStatus.Paused:
            return 'warning'
        case ExperimentStatus.ExposureFrozen:
            return 'highlight'
        case ExperimentStatus.Stopped:
            return 'completion'
    }
}

function normalizeExperimentFilterStatus(status: string | undefined): ExperimentStatus | 'all' {
    if (!status) {
        return 'all'
    }

    const normalizedStatus = status.toLowerCase()

    if (normalizedStatus === 'complete') {
        return ExperimentStatus.Stopped
    }

    if (Object.values(ExperimentStatus).includes(normalizedStatus as ExperimentStatus)) {
        return normalizedStatus as ExperimentStatus
    }

    return 'all'
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface experimentsLogicValues {
    featureFlags: FeatureFlagsResult // featureFlagsLogic
    currentProjectId: number | null // projectLogic
    location: {
        pathname: string
        search: string
        hash: string
    } // router
    currentTeam: TeamPublicType | TeamType | null // teamLogic
    hasAvailableFeature: (feature: AvailableFeature, currentUsage?: number | undefined) => boolean // userLogic
    user: UserType | null // userLogic
    breadcrumbs: Breadcrumb[]
    count: number
    experiments: ExperimentsResult
    experimentsLoading: boolean
    experimentsStats: ExperimentVelocityStats
    experimentsStatsLoading: boolean
    featureFlagModalFeatureFlags: {
        count: number
        results: FeatureFlagType[]
    }
    featureFlagModalFeatureFlagsLoading: boolean
    featureFlagModalFilters: FeatureFlagModalFilters
    featureFlagModalPageFromURL: number
    featureFlagModalPagination: PaginationManual
    featureFlagModalParamsFromFilters: Record<string, any>
    filters: ExperimentsFilters
    hasLoadedExperiments: boolean
    pagination: PaginationManual
    paramsFromFilters: {
        archived?: boolean | undefined
        created_by_id?: number[] | undefined
        excluded_tags?: string[] | undefined
        limit: number
        offset: number
        order?: string | undefined
        page?: number | undefined
        search?: string | undefined
        status?: ExperimentStatus | 'all' | undefined
        tags?: string[] | undefined
    }
    sidePanelContext: SidePanelSceneContext
    tab: ExperimentsTabs
    unavailableFeatureFlagKeys: Set<string>
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface experimentsLogicActions {
    reportExperimentsListViewed: (listView: {
        archived: boolean
        experimentsShown: number
        hasSearch: boolean
        page: number
        statusFilter: string
    }) => {
        archived: boolean
        experimentsShown: number
        hasSearch: boolean
        page: number
        statusFilter: string
    } // eventUsageLogic
    reportExperimentsSettingsViewed: () => {
        value: true
    } // eventUsageLogic
    loadCurrentTeamSuccess: (
        currentTeam: TeamPublicType | null,
        payload?: any
    ) => {
        currentTeam: TeamPublicType | null
        payload?: any
    } // teamLogic
    updateCurrentTeamSuccess: (
        currentTeam: TeamPublicType | TeamType,
        payload?: Partial<TeamType> | undefined
    ) => {
        currentTeam: TeamPublicType | TeamType
        payload?: Partial<TeamType>
    } // teamLogic
    addToExperiments: (experiment: Experiment) => Experiment
    addToExperimentsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    addToExperimentsSuccess: (
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: Experiment[]
        },
        payload?: Experiment
    ) => {
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: Experiment[]
        }
        payload?: Experiment
    }
    archiveExperiment: ({ id, disableFeatureFlag }: { disableFeatureFlag: boolean; id: number }) => {
        id: number
        disableFeatureFlag: boolean
    }
    archiveExperimentFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    archiveExperimentSuccess: (
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: Experiment[]
        },
        payload?: {
            id: number
            disableFeatureFlag: boolean
        }
    ) => {
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: Experiment[]
        }
        payload?: {
            id: number
            disableFeatureFlag: boolean
        }
    }
    copyExperimentToProject: (payload: {
        featureFlagKey?: string
        id: number
        name?: string
        onSuccess?: () => void
        targetProjectId: number
        targetTeamId: number
    }) => {
        id: number
        targetProjectId: number
        targetTeamId: number
        featureFlagKey?: string
        name?: string
        onSuccess?: () => void
    }
    copyExperimentToProjectFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    copyExperimentToProjectSuccess: (
        experiments: ExperimentsResult,
        payload?: {
            id: number
            targetProjectId: number
            targetTeamId: number
            featureFlagKey?: string
            name?: string
            onSuccess?: () => void
        }
    ) => {
        experiments: ExperimentsResult
        payload?: {
            id: number
            targetProjectId: number
            targetTeamId: number
            featureFlagKey?: string
            name?: string
            onSuccess?: () => void
        }
    }
    duplicateExperiment: (payload: { featureFlagKey?: string; id: number; name?: string }) => {
        id: number
        featureFlagKey?: string
        name?: string
    }
    duplicateExperimentFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    duplicateExperimentSuccess: (
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: any[]
        },
        payload?: {
            id: number
            featureFlagKey?: string
            name?: string
        }
    ) => {
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: any[]
        }
        payload?: {
            id: number
            featureFlagKey?: string
            name?: string
        }
    }
    loadExperiments: (_: void) => void
    loadExperimentsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadExperimentsStats: () => any
    loadExperimentsStatsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadExperimentsStatsSuccess: (
        experimentsStats: ExperimentVelocityStats,
        payload?: any
    ) => {
        experimentsStats: ExperimentVelocityStats
        payload?: any
    }
    loadExperimentsSuccess: (
        experiments: ExperimentsResult,
        payload?: void
    ) => {
        experiments: ExperimentsResult
        payload?: void
    }
    loadFeatureFlagModalFeatureFlags: (_: void) => void
    loadFeatureFlagModalFeatureFlagsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadFeatureFlagModalFeatureFlagsSuccess: (
        featureFlagModalFeatureFlags: {
            count: number
            results: FeatureFlagType[]
        },
        payload?: void
    ) => {
        featureFlagModalFeatureFlags: {
            count: number
            results: FeatureFlagType[]
        }
        payload?: void
    }
    resetFeatureFlagModalFilters: () => {
        value: true
    }
    setExperimentsFilters: (
        filters: Partial<ExperimentsFilters>,
        replace?: boolean
    ) => {
        filters: Partial<ExperimentsFilters>
        replace: boolean | undefined
    }
    setExperimentsTab: (tabKey: ExperimentsTabs) => {
        tabKey: ExperimentsTabs
    }
    setFeatureFlagModalFilters: (
        filters: Partial<FeatureFlagModalFilters>,
        replace?: boolean
    ) => {
        filters: Partial<FeatureFlagModalFilters>
        replace: boolean | undefined
    }
    unarchiveExperiment: (id: number) => number
    unarchiveExperimentFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    unarchiveExperimentSuccess: (
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: Experiment[]
        },
        payload?: number
    ) => {
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: Experiment[]
        }
        payload?: number
    }
    updateExperiments: (experiment: Experiment) => Experiment
    updateExperimentsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    updateExperimentsSuccess: (
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: Experiment[]
        },
        payload?: Experiment
    ) => {
        experiments: {
            count: number
            filters?: ExperimentsFilters | null | undefined
            next?: string | null | undefined
            previous?: string | null | undefined
            results: Experiment[]
        }
        payload?: Experiment
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface experimentsLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        count: (experiments: ExperimentsResult) => number
        paramsFromFilters: (filters: ExperimentsFilters) => {
            archived?: boolean | undefined
            created_by_id?: number[] | undefined
            excluded_tags?: string[] | undefined
            limit: number
            offset: number
            order?: string | undefined
            page?: number | undefined
            search?: string | undefined
            status?: ExperimentStatus | 'all' | undefined
            tags?: string[] | undefined
        }
        featureFlagModalParamsFromFilters: (
            featureFlagModalFilters: FeatureFlagModalFilters,
            currentTeam: TeamPublicType | TeamType | null
        ) => Record<string, any>
        featureFlagModalPageFromURL: (searchParams: Record<string, any>) => number
        featureFlagModalPagination: (
            featureFlagModalFilters: FeatureFlagModalFilters,
            featureFlagModalFeatureFlags: {
                count: number
                results: FeatureFlagType[]
            },
            featureFlagModalPageFromURL: number
        ) => PaginationManual
        pagination: (filters: ExperimentsFilters, count: number) => PaginationManual
        unavailableFeatureFlagKeys: (featureFlags: FeatureFlagsResult, experiments: ExperimentsResult) => Set<string>
    }
}

export type experimentsLogicType = MakeLogicType<
    experimentsLogicValues,
    experimentsLogicActions,
    Record<string, any>,
    experimentsLogicMeta
>

export const experimentsLogic = kea<experimentsLogicType>([
    path(['scenes', 'experiments', 'experimentsLogic']),
    connect(() => ({
        values: [
            projectLogic,
            ['currentProjectId'],
            userLogic,
            ['user', 'hasAvailableFeature'],
            featureFlagsLogic,
            ['featureFlags'],
            router,
            ['location'],
            teamLogic,
            ['currentTeam'],
        ],
        actions: [
            teamLogic,
            ['loadCurrentTeamSuccess', 'updateCurrentTeamSuccess'],
            eventUsageLogic,
            ['reportExperimentsListViewed', 'reportExperimentsSettingsViewed'],
        ],
    })),
    actions({
        setExperimentsTab: (tabKey: ExperimentsTabs) => ({ tabKey }),
        setExperimentsFilters: (filters: Partial<ExperimentsFilters>, replace?: boolean) => ({ filters, replace }),
        setFeatureFlagModalFilters: (filters: Partial<FeatureFlagModalFilters>, replace?: boolean) => ({
            filters,
            replace,
        }),
        resetFeatureFlagModalFilters: true,
    }),
    reducers({
        filters: [
            DEFAULT_FILTERS,
            {
                setExperimentsFilters: (state, { filters, replace }) => {
                    if (replace) {
                        return { ...filters }
                    }
                    return { ...state, ...filters }
                },
            },
        ],
        featureFlagModalFilters: [
            DEFAULT_MODAL_FILTERS,
            {
                setFeatureFlagModalFilters: (state, { filters, replace }) => {
                    if (replace) {
                        return { ...filters }
                    }
                    return { ...state, ...filters }
                },
                resetFeatureFlagModalFilters: () => DEFAULT_MODAL_FILTERS,
            },
        ],
        tab: [
            ExperimentsTabs.All as ExperimentsTabs,
            {
                setExperimentsTab: (state, { tabKey }) => tabKey ?? state,
            },
        ],
        hasLoadedExperiments: [
            false,
            {
                loadExperimentsSuccess: () => true,
                loadExperimentsFailure: () => true,
            },
        ],
    }),
    listeners(({ actions, values }) => ({
        setExperimentsTab: ({ tabKey }) => {
            if (tabKey === ExperimentsTabs.Settings) {
                actions.reportExperimentsSettingsViewed()
            }
        },
        setExperimentsFilters: async (_, breakpoint) => {
            // Only debounce after the first load — the debounce is for search input,
            // but the initial load from urlToAction should fire immediately.
            if (values.hasLoadedExperiments || values.experimentsLoading) {
                await breakpoint(300)
            }
            actions.loadExperiments()
        },
        setFeatureFlagModalFilters: async (_, breakpoint) => {
            await breakpoint(300)
            actions.loadFeatureFlagModalFeatureFlags()
        },
        resetFeatureFlagModalFilters: () => {
            actions.loadFeatureFlagModalFeatureFlags()
        },
        loadExperimentsSuccess: ({ experiments }) => {
            // The list also loads behind the other tabs of the scene, where nobody sees it.
            if (values.tab === ExperimentsTabs.All) {
                const filters = experiments.filters ?? {}
                actions.reportExperimentsListViewed({
                    experimentsShown: experiments.results.length,
                    statusFilter: filters.status ?? 'all',
                    page: filters.page ?? 1,
                    hasSearch: !!filters.search,
                    archived: !!filters.archived,
                })
            }
        },
        loadCurrentTeamSuccess: () => {
            if (values.featureFlagModalFeatureFlags.results.length > 0) {
                actions.loadFeatureFlagModalFeatureFlags()
            }
        },
        updateCurrentTeamSuccess: () => {
            if (values.featureFlagModalFeatureFlags.results.length > 0) {
                actions.loadFeatureFlagModalFeatureFlags()
            }
        },
    })),
    loaders(({ values }) => ({
        experiments: [
            { results: [], count: 0, filters: DEFAULT_FILTERS, offset: 0 } as ExperimentsResult,
            {
                loadExperiments: async (_: void, breakpoint) => {
                    // A filter change during the request must not relabel this response.
                    const filters = values.filters
                    // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. Use experimentsList() from 'products/experiments/frontend/generated/api' instead.
                    const response = await api.get(
                        `api/projects/${values.currentProjectId}/experiments?${toParams(values.paramsFromFilters)}`
                    )
                    // Discard stale responses that resolve after a newer search has fired
                    breakpoint()
                    return {
                        ...response,
                        offset: values.paramsFromFilters.offset,
                        filters,
                    }
                },
                archiveExperiment: async ({ id, disableFeatureFlag }: { id: number; disableFeatureFlag: boolean }) => {
                    // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsArchiveCreate() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
                    await api.create(`api/projects/${values.currentProjectId}/experiments/${id}/archive`, {
                        disable_feature_flag: disableFeatureFlag,
                    })
                    lemonToast.info('Experiment archived')
                    return {
                        ...values.experiments,
                        results: values.experiments.results.filter((experiment) => experiment.id !== id),
                        count: values.experiments.count - 1,
                    }
                },
                unarchiveExperiment: async (id: number) => {
                    // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsUnarchiveCreate() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
                    await api.create(`api/projects/${values.currentProjectId}/experiments/${id}/unarchive`)
                    lemonToast.info('Experiment unarchived')
                    return {
                        ...values.experiments,
                        results: values.experiments.results.filter((experiment) => experiment.id !== id),
                        count: values.experiments.count - 1,
                    }
                },
                duplicateExperiment: async (payload: { id: number; featureFlagKey?: string; name?: string }) => {
                    const data: Record<string, string> = {}
                    if (payload.featureFlagKey) {
                        data.feature_flag_key = payload.featureFlagKey
                    }
                    if (payload.name) {
                        data.name = payload.name
                    }
                    // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsDuplicateCreate() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
                    const duplicatedExperiment = await api.create(
                        `api/projects/${values.currentProjectId}/experiments/${payload.id}/duplicate`,
                        data
                    )
                    lemonToast.success('Experiment duplicated successfully')
                    // Navigate to the newly created experiment
                    router.actions.push(urls.experiment(duplicatedExperiment.id))

                    return {
                        ...values.experiments,
                        results: [duplicatedExperiment, ...values.experiments.results],
                        count: values.experiments.count + 1,
                    }
                },
                copyExperimentToProject: async (payload: {
                    id: number
                    targetProjectId: number
                    targetTeamId: number
                    featureFlagKey?: string
                    name?: string
                    onSuccess?: () => void
                }) => {
                    const data: Record<string, any> = { target_team_id: payload.targetTeamId }
                    if (payload.featureFlagKey) {
                        data.feature_flag_key = payload.featureFlagKey
                    }
                    if (payload.name) {
                        data.name = payload.name
                    }
                    // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsCopyToProjectCreate() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
                    const newExperiment = await api.create(
                        `api/projects/${values.currentProjectId}/experiments/${payload.id}/copy_to_project`,
                        data
                    )
                    lemonToast.success('Experiment copied to project', {
                        button: {
                            label: 'Go to experiment',
                            action: () => {
                                window.location.href = urls.project(
                                    payload.targetProjectId,
                                    urls.experiment(newExperiment.id)
                                )
                            },
                        },
                    })
                    payload.onSuccess?.()
                    return values.experiments
                },
                addToExperiments: (experiment: Experiment) => {
                    return {
                        ...values.experiments,
                        results: [...values.experiments.results, experiment],
                        count: values.experiments.count + 1,
                    }
                },
                updateExperiments: (experiment: Experiment) => {
                    return {
                        ...values.experiments,
                        results: values.experiments.results.map((exp) => (exp.id === experiment.id ? experiment : exp)),
                        count: values.experiments.count,
                    }
                },
            },
        ],
        featureFlagModalFeatureFlags: [
            { results: [], count: 0 } as { results: FeatureFlagType[]; count: number },
            {
                loadFeatureFlagModalFeatureFlags: async (_: void, breakpoint) => {
                    // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. Use featureFlagsList() from 'products/feature_flags/frontend/generated/api' instead.
                    const response = await api.get(
                        `api/projects/${values.currentProjectId}/feature_flags/?${toParams({
                            ...values.featureFlagModalParamsFromFilters,
                            eligible_for_experiment: true,
                        })}`
                    )
                    // Discard stale responses that resolve after a newer search has fired
                    breakpoint()
                    return response
                },
            },
        ],
        experimentsStats: [
            {
                launched_last_30d: 0,
                launched_previous_30d: 0,
                percent_change: 0,
                active_experiments: 0,
                completed_last_30d: 0,
            } as ExperimentVelocityStats,
            {
                loadExperimentsStats: async () => {
                    // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsStatsRetrieve() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
                    const response = await api.get(`api/projects/${values.currentProjectId}/experiments/stats/`)
                    return response
                },
            },
        ],
    })),
    selectors(() => ({
        count: [(selectors) => [selectors.experiments], (experiments: ExperimentsResult) => experiments.count],
        paramsFromFilters: [
            (s) => [s.filters],
            (filters: ExperimentsFilters) => ({
                ...filters,
                limit: EXPERIMENTS_PER_PAGE,
                offset: filters.page ? (filters.page - 1) * EXPERIMENTS_PER_PAGE : 0,
            }),
        ],
        featureFlagModalParamsFromFilters: [
            (s) => [s.featureFlagModalFilters, s.currentTeam],
            (
                filters: FeatureFlagModalFilters,
                currentTeam: null | import('~/types').TeamPublicType | import('~/types').TeamType
            ) => {
                const params: Record<string, any> = {
                    ...filters,
                    limit: FLAGS_PER_PAGE,
                    offset: filters.page ? (filters.page - 1) * FLAGS_PER_PAGE : 0,
                }

                // Add evaluation contexts filter if required by team
                if (currentTeam?.require_evaluation_contexts) {
                    params.has_evaluation_contexts = true
                }

                return params
            },
        ],
        featureFlagModalPageFromURL: [
            () => [router.selectors.searchParams],
            (searchParams: Record<string, any>) => {
                return parseInt(searchParams['ff_page']) || 1
            },
        ],
        featureFlagModalPagination: [
            (s) => [s.featureFlagModalFilters, s.featureFlagModalFeatureFlags, s.featureFlagModalPageFromURL],
            (
                filters: FeatureFlagModalFilters,
                featureFlags: {
                    count: number
                    results: FeatureFlagType[]
                },
                urlPage: number
            ): PaginationManual => {
                const currentPage = Math.max(filters.page || 1, urlPage)

                const hasNextPage = featureFlags.count > currentPage * FLAGS_PER_PAGE
                const hasPreviousPage = currentPage > 1
                const needsPagination = featureFlags.count > FLAGS_PER_PAGE

                return {
                    controlled: true,
                    pageSize: FLAGS_PER_PAGE,
                    currentPage,
                    entryCount: featureFlags.count,
                    onForward:
                        needsPagination && hasNextPage
                            ? () => {
                                  experimentsLogic.actions.setFeatureFlagModalFilters({ page: currentPage + 1 })
                              }
                            : undefined,
                    onBackward:
                        needsPagination && hasPreviousPage
                            ? () => {
                                  experimentsLogic.actions.setFeatureFlagModalFilters({
                                      page: Math.max(1, currentPage - 1),
                                  })
                              }
                            : undefined,
                }
            },
        ],
        pagination: [
            (s) => [s.filters, s.count],
            (filters: ExperimentsFilters, count: number): PaginationManual => {
                return {
                    controlled: true,
                    pageSize: EXPERIMENTS_PER_PAGE,
                    currentPage: filters.page || 1,
                    entryCount: count,
                }
            },
        ],
        // TRICKY: we do not load all feature flags here, just the latest ones.
        unavailableFeatureFlagKeys: [
            (s) => [featureFlagsLogic.selectors.featureFlags, s.experiments],
            (featureFlags: FeatureFlagsResult, experiments: ExperimentsResult) => {
                return new Set([
                    ...featureFlags.results.map((flag) => flag.key),
                    ...experiments.results.map((experiment) => experiment.feature_flag_key),
                ])
            },
        ],
    })),
    selectors({
        breadcrumbs: [
            () => [],
            (): Breadcrumb[] => [
                {
                    key: 'experiments',
                    name: 'Experiments',
                    iconType: 'experiment',
                },
            ],
        ],
        [SIDE_PANEL_CONTEXT_KEY]: [
            () => [],
            (): SidePanelSceneContext => ({
                activity_scope: ActivityScope.EXPERIMENT,
            }),
        ],
    }),
    afterMount(({ actions, values }) => {
        actions.loadExperimentsStats()
        // Sync modal page with URL on mount. Eligible flags themselves are loaded lazily when the
        // "link existing flag" modal sets or resets its filters, not on every list mount.
        const urlPage = values.featureFlagModalPageFromURL
        if (urlPage !== 1) {
            actions.setFeatureFlagModalFilters({ page: urlPage })
        }
    }),
    actionToUrl(({ values }) => {
        const changeUrl = ():
            | [
                  string,
                  Record<string, any>,
                  Record<string, any>,
                  {
                      replace: boolean
                  },
              ]
            | void => {
            const searchParams: Record<string, string | number | boolean | number[] | string[]> = {
                ...values.filters,
            }

            if (values.tab !== ExperimentsTabs.All) {
                searchParams['tab'] = values.tab
            }

            // Preserve the activity deep-link param only when on the history tab
            const currentActivity = router.values.searchParams['activity']
            if (currentActivity && values.tab === ExperimentsTabs.History) {
                searchParams['activity'] = currentActivity
            }

            return [router.values.location.pathname, searchParams, router.values.hashParams, { replace: true }]
        }

        const changeFeatureFlagModalUrl = ():
            | [
                  string,
                  Record<string, any>,
                  Record<string, any>,
                  {
                      replace: boolean
                  },
              ]
            | void => {
            const searchParams: Record<string, string | number | boolean | number[] | string[]> = {
                ...values.filters,
            }

            if (values.tab !== ExperimentsTabs.All) {
                searchParams['tab'] = values.tab
            }

            // Add feature flag modal page to URL if not page 1
            const modalPage = values.featureFlagModalFilters.page || 1
            if (modalPage !== 1) {
                searchParams['ff_page'] = modalPage
            }

            return [router.values.location.pathname, searchParams, router.values.hashParams, { replace: true }]
        }

        return {
            setExperimentsFilters: changeUrl,
            setExperimentsTab: changeUrl,
            setFeatureFlagModalFilters: changeFeatureFlagModalUrl,
            resetFeatureFlagModalFilters: changeFeatureFlagModalUrl,
        }
    }),
    urlToAction(({ actions, values }) => ({
        [urls.experiments()]: async (_, searchParams) => {
            const tabInURL = searchParams['tab']

            if (!tabInURL) {
                if (values.tab !== ExperimentsTabs.All) {
                    actions.setExperimentsTab(ExperimentsTabs.All)
                }
            } else if (tabInURL !== values.tab) {
                actions.setExperimentsTab(tabInURL)
            }

            const { page, search, status, created_by_id, order, archived, tags, excluded_tags } = searchParams
            const pageFiltersFromUrl: Partial<ExperimentsFilters> = {
                search,
                created_by_id: parseNumericArrayFilter(created_by_id),
                order,
                tags: parseTagsFilter(tags),
                excluded_tags: parseTagsFilter(excluded_tags),
            }

            pageFiltersFromUrl.status = normalizeExperimentFilterStatus(status)
            pageFiltersFromUrl.page = page !== undefined ? parseInt(page) : 1
            pageFiltersFromUrl.archived = String(archived) === 'true'

            actions.setExperimentsFilters({ ...DEFAULT_FILTERS, ...pageFiltersFromUrl })
        },
    })),
])